diff --git a/.gitattributes b/.gitattributes index 039b3be918b8e17b36df260ad357da7f68490944..662edd9984a564c5251312b5bb482aa49a3d91e0 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1431,3 +1431,54 @@ koenbollen--jl.ef5e34c/tests/executable filter=lfs diff=lfs merge=lfs -text koenrh--s3enum.1e95b89/environment/executable filter=lfs diff=lfs merge=lfs -text koenrh--s3enum.1e95b89/tests/executable filter=lfs diff=lfs merge=lfs -text koide3--iridescence.eb11109/environment/executable filter=lfs diff=lfs merge=lfs -text +koide3--iridescence.eb11109/tests/executable filter=lfs diff=lfs merge=lfs -text +koihik--luaformatter.29afe10/environment/executable filter=lfs diff=lfs merge=lfs -text +koihik--luaformatter.29afe10/tests/executable filter=lfs diff=lfs merge=lfs -text +kokkos--kokkos-kernels.4a10bcb/environment/executable filter=lfs diff=lfs merge=lfs -text +kokkos--kokkos-kernels.4a10bcb/tests/executable filter=lfs diff=lfs merge=lfs -text +kongaskristjan--fire-hpp.7d000fd/environment/executable filter=lfs diff=lfs merge=lfs -text +kongaskristjan--fire-hpp.7d000fd/tests/executable filter=lfs diff=lfs merge=lfs -text +kovacsv--occt-import-js.41e4708/environment/executable filter=lfs diff=lfs merge=lfs -text +kovacsv--occt-import-js.41e4708/tests/executable filter=lfs diff=lfs merge=lfs -text +kovetskiy--manul.b036c31/environment/executable filter=lfs diff=lfs merge=lfs -text +kovetskiy--manul.b036c31/tests/executable filter=lfs diff=lfs merge=lfs -text +kpcyrd--rshijack.acf2bc8/environment/executable filter=lfs diff=lfs merge=lfs -text +kpcyrd--rshijack.acf2bc8/tests/executable filter=lfs diff=lfs merge=lfs -text +kreuzwerker--envplate.ec00ede/environment/executable filter=lfs diff=lfs merge=lfs -text +kreuzwerker--envplate.ec00ede/tests/executable filter=lfs diff=lfs merge=lfs -text +kthohr--optim.5453f48/environment/executable filter=lfs diff=lfs merge=lfs -text +kthohr--optim.5453f48/tests/executable filter=lfs diff=lfs merge=lfs -text +kubecfg--kubecfg.64da3e7/environment/executable filter=lfs diff=lfs merge=lfs -text +kubecfg--kubecfg.64da3e7/tests/executable filter=lfs diff=lfs merge=lfs -text +kubernauts--tk8.87af949/environment/executable filter=lfs diff=lfs merge=lfs -text +kubernauts--tk8.87af949/tests/executable filter=lfs diff=lfs merge=lfs -text +kubernetes--sig-security.e7f5f07/environment/executable filter=lfs diff=lfs merge=lfs -text +kubernetes--sig-security.e7f5f07/tests/executable filter=lfs diff=lfs merge=lfs -text +kudrykv--latex-yearly-planner.c4/environment/executable filter=lfs diff=lfs merge=lfs -text +kudrykv--latex-yearly-planner.c4/tests/executable filter=lfs diff=lfs merge=lfs -text +kuvaus--llamagptj-chat.e022976/environment/executable filter=lfs diff=lfs merge=lfs -text +kuvaus--llamagptj-chat.e022976/tests/executable filter=lfs diff=lfs merge=lfs -text +kxzk--scraping-with-rust.f0f9b04/environment/executable filter=lfs diff=lfs merge=lfs -text +kxzk--scraping-with-rust.f0f9b04/tests/executable filter=lfs diff=lfs merge=lfs -text +kyclark--command-line-rust.10d98/environment/executable filter=lfs diff=lfs merge=lfs -text +kyclark--command-line-rust.10d98/tests/executable filter=lfs diff=lfs merge=lfs -text +kylebanks--depth.5ba21c0/environment/executable filter=lfs diff=lfs merge=lfs -text +kylebanks--depth.5ba21c0/tests/executable filter=lfs diff=lfs merge=lfs -text +kylebanks--goggles.1811fc5/environment/executable filter=lfs diff=lfs merge=lfs -text +kylebanks--goggles.1811fc5/tests/executable filter=lfs diff=lfs merge=lfs -text +kylelemons--go-gypsy.95000da/environment/executable filter=lfs diff=lfs merge=lfs -text +kylelemons--go-gypsy.95000da/tests/executable filter=lfs diff=lfs merge=lfs -text +kyokomi--emoji.eb10848/environment/executable filter=lfs diff=lfs merge=lfs -text +kyokomi--emoji.eb10848/tests/executable filter=lfs diff=lfs merge=lfs -text +kzampog--cilantro.cd473eb/environment/executable filter=lfs diff=lfs merge=lfs -text +kzampog--cilantro.cd473eb/tests/executable filter=lfs diff=lfs merge=lfs -text +landlock-lsm--go-landlock.e573f5/environment/executable filter=lfs diff=lfs merge=lfs -text +landlock-lsm--go-landlock.e573f5/tests/executable filter=lfs diff=lfs merge=lfs -text +lava--matplotlib-cpp.ef0383f/environment/executable filter=lfs diff=lfs merge=lfs -text +lava--matplotlib-cpp.ef0383f/tests/executable filter=lfs diff=lfs merge=lfs -text +layeh--kjv.0b6a9ce/environment/executable filter=lfs diff=lfs merge=lfs -text +layeh--kjv.0b6a9ce/tests/executable filter=lfs diff=lfs merge=lfs -text +lbcb-sci--racon.a2cfcac/environment/executable filter=lfs diff=lfs merge=lfs -text +lbcb-sci--racon.a2cfcac/tests/executable filter=lfs diff=lfs merge=lfs -text +lbcb-sci--raven.2c3d337/environment/executable filter=lfs diff=lfs merge=lfs -text +lbcb-sci--raven.2c3d337/tests/executable filter=lfs diff=lfs merge=lfs -text diff --git a/koide3--iridescence.eb11109/tests/Dockerfile b/koide3--iridescence.eb11109/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/koide3--iridescence.eb11109/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/koide3--iridescence.eb11109/tests/blobs/tests/generated_module_02.tar.gz b/koide3--iridescence.eb11109/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2ea8a8d711c93d0d92685013a6dd16d4b525df0c --- /dev/null +++ b/koide3--iridescence.eb11109/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de38b1b4556b940a452d23160ec09e39ec2b1fbae2f46ccbfd70a94aa81d6760 +size 23828 diff --git a/koide3--iridescence.eb11109/tests/docker-compose.yaml b/koide3--iridescence.eb11109/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/koide3--iridescence.eb11109/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/koide3--iridescence.eb11109/tests/download.sh b/koide3--iridescence.eb11109/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..5a2226a61c94c6c8b816ba4939bc8c374280cbb3 --- /dev/null +++ b/koide3--iridescence.eb11109/tests/download.sh @@ -0,0 +1,164 @@ +#!/usr/bin/env bash +# Download / dependency-prefetch stage for koide3/iridescence. +# Sourced as: source /source_ro/download.sh +# This script: +# - installs the system build dependencies needed to compile the examples +# - downloads and stages the repository's thirdparty git submodules +# (imgui, implot, ImGuizmo, portable-file-dialogs) into a writable cache +# - exports IRIDESCENCE_THIRDPARTY_CACHE for build.sh to consume +# - exports LD_LIBRARY_PATH so the default GCC 13 toolchain's matching +# libstdc++ (which exports GLIBCXX_3.4.32) is found at runtime +# It performs NO compilation, linking, testing, or packaging steps. + +# --- source-safe failure helper ------------------------------------------- +fail() { + echo "[download] ERROR: $*" >&2 + if [ "${BASH_SOURCE[0]}" = "$0" ]; then + exit 1 + else + return 1 + fi +} + +if [ -x /usr/bin/apt-get ] || [ -x /usr/local/bin/apt-get ]; then + export DEBIAN_FRONTEND=noninteractive + if ! apt-get update; then + fail "apt-get update failed" + return 1 + fi + # Build dependencies required by iridescence's CMake config: + # - libglfw3-dev : find_package(glfw3) -> imported target `glfw` + # - libglvnd-dev : find_package(OpenGL REQUIRED) / OpenGL::GL (GLVND) + # - libglm-dev : find_package(glm) -> glm::glm + # - libeigen3-dev : find_package(Eigen3) -> Eigen3::Eigen (header-only) + # - libpng-dev : find_package(PNG) -> PNG::PNG + # - libjpeg-dev : find_package(JPEG) -> JPEG::JPEG + if ! apt-get install -y --no-install-recommends \ + libglfw3-dev libglvnd-dev libglm-dev libeigen3-dev libpng-dev libjpeg-dev; then + fail "apt-get install of build dependencies failed" + return 1 + fi +else + echo "[download] apt-get not found; assuming build dependencies are already present." +fi + +# --- stage thirdparty submodules into a writable cache ---------------------- +# The repository's CMakeLists.txt compiles these vendored sources directly +# (thirdparty/imgui/*.cpp, thirdparty/implot/*.cpp, thirdparty/ImGuizmo/*.cpp, +# thirdparty/portable-file-dialogs/portable-file-dialogs.h). The gitlinks pin +# the exact commits below. We fetch those commits as archives and unpack them +# so build.sh can install offline. +CACHE_DIR="${IRIDESCENCE_THIRDPARTY_CACHE:-${HOME}/.cache/iridescence_thirdparty}" +export IRIDESCENCE_THIRDPARTY_CACHE="$CACHE_DIR" + +if [ ! -d "$CACHE_DIR" ]; then + if ! mkdir -p "$CACHE_DIR"; then + fail "could not create cache dir $CACHE_DIR" + return 1 + fi +fi + +if [ -w "$CACHE_DIR" ] && [ -z "$(ls -A "$CACHE_DIR")" ]; then + echo "[download] staging thirdparty submodules into $CACHE_DIR" +fi + +# Populate each submodule if it is not already complete. +stage_submodule() { + local name="$1" + local owner_repo="$2" + local sha="$3" + local dst="$CACHE_DIR/$name" + # Marker used to detect that this submodule is already fully staged. + local marker="" + case "$name" in + imgui) marker="imgui.cpp";; + implot) marker="implot.cpp";; + ImGuizmo) marker="ImGuizmo.cpp";; + portable-file-dialogs) marker="portable-file-dialogs.h";; + *) fail "unknown submodule $name"; return 1;; + esac + if [ -z "$marker" ]; then + fail "no marker for submodule $name" + return 1 + fi + if [ -f "$dst/$marker" ]; then + echo "[download] $name already staged" + return 0 + fi + + local url="https://github.com/${owner_repo}/archive/${sha}.tar.gz" + local archive="$CACHE_DIR/${name}.tgz" + local extract="$CACHE_DIR/${name}.x" + if ! wget -q -O "$archive" "$url"; then + fail "failed to download $name from $url" + return 1 + fi + if [ -d "$extract" ]; then + if ! rm -rf "$extract"; then + fail "could not clear extract dir $extract" + return 1 + fi + fi + if ! mkdir -p "$extract"; then + fail "could not mkdir $extract" + return 1 + fi + if ! tar -xzf "$archive" -C "$extract"; then + fail "failed to extract $name archive" + return 1 + fi + if ! rm -f "$archive"; then + fail "could not remove archive $archive" + return 1 + fi + if [ ! -d "$extract/${name}-${sha}" ]; then + fail "extracted directory ${name}-${sha} not found" + return 1 + fi + if [ -d "$dst" ]; then + if ! rm -rf "$dst"; then + fail "could not clear existing $dst" + return 1 + fi + fi + if ! mv "$extract/${name}-${sha}" "$dst"; then + fail "could not move ${name}-${sha} to $dst" + return 1 + fi + if ! rm -rf "$extract"; then + fail "could not clear extract dir $extract" + return 1 + fi + echo "[download] staged $name (${sha})" + echo "$sha" > "$CACHE_DIR/${name}.staged" +} + +# Exact pinned commits from the repository gitlinks (.gitmodules + git tree). +stage_submodule imgui ocornut/imgui 88dfd85e9296fc03ac858f66cc6507ba443294ef +if [ $? -ne 0 ]; then return 1; fi +stage_submodule implot epezent/implot 8879c99aef760379c85d5a7a0de7f70e7af3210c +if [ $? -ne 0 ]; then return 1; fi +stage_submodule ImGuizmo CedricGuillemet/ImGuizmo ba662b119d64f9ab700bb2cd7b2781f9044f5565 +if [ $? -ne 0 ]; then return 1; fi +stage_submodule portable-file-dialogs samhocevar/portable-file-dialogs ece1202552b887bb2dc72d0364f5b2069639e53c +if [ $? -ne 0 ]; then return 1; fi + +# Sanity check that the staged imgui carries the glfw/opengl3 backends that the +# iridescence library source list compiles in. +if [ ! -f "$CACHE_DIR/imgui/backends/imgui_impl_glfw.cpp" ]; then + fail "staged imgui is missing backends/imgui_impl_glfw.cpp" + return 1 +fi +if [ ! -f "$CACHE_DIR/imgui/backends/imgui_impl_opengl3.cpp" ]; then + fail "staged imgui is missing backends/imgui_impl_opengl3.cpp" + return 1 +fi + +# --- runtime toolchain libstdc++ discovery --------------------------------- +# The default compiler is xPack GCC 13.3.0 (in /opt/gcc-13). Its libstdc++.so.6 +# (6.0.32) exports GLIBCXX_3.4.32 and is required by binaries compiled with it, +# but it is not registered with ldconfig. Export the path so the matching +# libstdc++ is used both when linking and at runtime. +export LD_LIBRARY_PATH="/opt/gcc-13/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" + +echo "[download] dependency stage complete" diff --git a/koide3--iridescence.eb11109/tests/executable b/koide3--iridescence.eb11109/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..75a6a38ce4e1d188888075baa003202165716e54 --- /dev/null +++ b/koide3--iridescence.eb11109/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c3c1e1b084cfb4c035d82919d14f99a87b152f97b0d7c75db532f72800fff5e3 +size 5115392 diff --git a/koide3--iridescence.eb11109/tests/harbor_configure_apt_mirror.sh b/koide3--iridescence.eb11109/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/koide3--iridescence.eb11109/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/koide3--iridescence.eb11109/tests/harbor_prepare_download_env.sh b/koide3--iridescence.eb11109/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/koide3--iridescence.eb11109/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/koide3--iridescence.eb11109/tests/programgym_evaluator.py b/koide3--iridescence.eb11109/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/koide3--iridescence.eb11109/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/koide3--iridescence.eb11109/tests/programgym_task.json b/koide3--iridescence.eb11109/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..fcf8ef24c026bcef50b54a9c5410d001d993b237 --- /dev/null +++ b/koide3--iridescence.eb11109/tests/programgym_task.json @@ -0,0 +1,319 @@ +{ + "branches": { + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_glfw_platform_override[]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_glfw_platform_override[null]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_glfw_platform_override[offscreen]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_glfw_platform_override[wayland]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_glfw_platform_override[x11]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_piped_stdin[default]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_piped_stdin[empty]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_piped_stdin[nul4k]", + "eval.tests.test_display_control_byte_echo.test_control_byte_echo_independent_of_piped_stdin[script]", + "eval.tests.test_display_control_byte_echo.test_embedded_ansi_escape_sequence_is_echoed_verbatim[clear]", + "eval.tests.test_display_control_byte_echo.test_embedded_ansi_escape_sequence_is_echoed_verbatim[cursor]", + "eval.tests.test_display_control_byte_echo.test_embedded_ansi_escape_sequence_is_echoed_verbatim[red]", + "eval.tests.test_display_control_byte_echo.test_embedded_ansi_escape_sequence_is_echoed_verbatim[reset]", + "eval.tests.test_display_control_byte_echo.test_embedded_control_byte_is_echoed_verbatim[cr_no_extra_line]", + "eval.tests.test_display_control_byte_echo.test_embedded_control_byte_is_echoed_verbatim[mixed_nl_plus_tab]", + "eval.tests.test_display_control_byte_echo.test_embedded_control_byte_is_echoed_verbatim[single_nl_3lines]", + "eval.tests.test_display_control_byte_echo.test_embedded_control_byte_is_echoed_verbatim[tab_no_extra_line]", + "eval.tests.test_display_control_byte_echo.test_embedded_control_byte_is_echoed_verbatim[three_nl_5lines]", + "eval.tests.test_display_control_byte_echo.test_escape_injection_composes_with_the_995_byte_truncation", + "eval.tests.test_display_control_byte_echo.test_escape_injection_independent_of_glfw_platform_override[empty]", + "eval.tests.test_display_control_byte_echo.test_escape_injection_independent_of_glfw_platform_override[null]", + "eval.tests.test_display_control_byte_echo.test_escape_injection_independent_of_glfw_platform_override[offscreen]", + "eval.tests.test_display_control_byte_echo.test_escape_injection_independent_of_glfw_platform_override[wayland]", + "eval.tests.test_display_control_byte_echo.test_escape_injection_independent_of_glfw_platform_override[x11]", + "eval.tests.test_display_control_byte_echo.test_injected_esc_sequence_is_within_the_first_line_token", + "eval.tests.test_display_control_byte_echo.test_invariant_summary_line_stays_intact_behind_embedded_newline", + "eval.tests.test_display_control_byte_echo.test_the_control_byte_itself_is_present_in_the_stream[cr]", + "eval.tests.test_display_control_byte_echo.test_the_control_byte_itself_is_present_in_the_stream[mixed_has_nl]", + "eval.tests.test_display_control_byte_echo.test_the_control_byte_itself_is_present_in_the_stream[nl_one]", + "eval.tests.test_display_control_byte_echo.test_the_control_byte_itself_is_present_in_the_stream[nl_three]", + "eval.tests.test_display_control_byte_echo.test_the_control_byte_itself_is_present_in_the_stream[tab]", + "eval.tests.test_display_control_byte_echo.test_truncation_and_control_echo_compose_exactly", + "eval.tests.test_display_truncation.test_absolute_path_form_display_is_equal_ly_truncated", + "eval.tests.test_display_truncation.test_bytes_beyond_the_995_limit_are_dropped_from_the_echo", + "eval.tests.test_display_truncation.test_display_token_at_exactly_995_bytes_is_echoed_in_full[q_x993]", + "eval.tests.test_display_truncation.test_display_token_at_exactly_995_bytes_is_echoed_in_full[unix_slash990]", + "eval.tests.test_display_truncation.test_long_display_token_is_truncated_to_995_bytes[b996]", + "eval.tests.test_display_truncation.test_long_display_token_is_truncated_to_995_bytes[d4096]", + "eval.tests.test_display_truncation.test_long_display_token_is_truncated_to_995_bytes[f2000]", + "eval.tests.test_display_truncation.test_long_display_token_is_truncated_to_995_bytes[y5000]", + "eval.tests.test_display_truncation.test_multibyte_display_token_is_truncated_on_a_raw_byte_boundary", + "eval.tests.test_display_truncation.test_over_limit_display_echoes_fewer_bytes_than_supplied[far_over]", + "eval.tests.test_display_truncation.test_over_limit_display_echoes_fewer_bytes_than_supplied[few_over]", + "eval.tests.test_display_truncation.test_over_limit_display_echoes_fewer_bytes_than_supplied[one_over]", + "eval.tests.test_display_truncation.test_truncated_diagnostic_keeps_exact_two_line_structure[slash3000]", + "eval.tests.test_display_truncation.test_truncated_diagnostic_keeps_exact_two_line_structure[u7000]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_glfw_platform_override[]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_glfw_platform_override[null]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_glfw_platform_override[offscreen]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_glfw_platform_override[wayland]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_glfw_platform_override[x11]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_piped_stdin[default]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_piped_stdin[empty]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_piped_stdin[nul4k]", + "eval.tests.test_display_truncation.test_truncation_is_independent_of_piped_stdin[script]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[127.0.0.1:0.0]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:0.5]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:1080]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:1]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:42]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:99]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[:abc]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[foo]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[hostname:17]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[localhost:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[unix/:234]", + "eval.tests.test_glfw_diagnostic_formatting.test_bold_red_prefix_always_precedes_each_line[unix/:7]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[127.0.0.1:0.0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:0.5]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:1080]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:1]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:42]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:99]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[:abc]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[foo]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[hostname:17]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[localhost:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[unix/:234]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_echo_of_the_requested_display_address[unix/:7]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[127.0.0.1:0.0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:0.5]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:1080]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:1]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:42]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:99]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[:abc]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[None]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[foo]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[hostname:17]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[localhost:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[unix/:234]", + "eval.tests.test_glfw_diagnostic_formatting.test_colour_never_changes_signal_or_text[unix/:7]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[127.0.0.1:0.0]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:0.5]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:1080]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:1]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:42]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:99]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[:abc]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[None]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[foo]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[hostname:17]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[localhost:0]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[unix/:234]", + "eval.tests.test_glfw_diagnostic_formatting.test_diagnostics_are_wrapped_in_bold_red_ansi[unix/:7]", + "eval.tests.test_glfw_diagnostic_formatting.test_numeric_glfw_error_code_is_literal[None]", + "eval.tests.test_glfw_diagnostic_formatting.test_numeric_glfw_error_code_is_literal[]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_diagnostics_are_complete_in_stderr_despite_segfault_termination[:0]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_diagnostics_are_complete_in_stderr_despite_segfault_termination[None]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_diagnostics_are_complete_in_stderr_despite_segfault_termination[]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_diagnostics_are_complete_in_stderr_despite_segfault_termination[host:4]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_missing_empty_and_space_display_are_three_distinct_diagnostics", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[ ]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[: 0]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[:0]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[:7]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[None]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[a b]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[host:9]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[machine:1]", + "eval.tests.test_glfw_diagnostics_byte_stream.test_stderr_byte_stream_is_exactly_two_wrapped_lines_ending_in_reset_then_newline[unix/:3]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[None]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[cocoa]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[headless]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[not-a-real-platform]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[null]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[offscreen]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[osmesa]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[wayland]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[win32]", + "eval.tests.test_platform_selection_is_ignored.test_no_platform_override_changes_the_x11_failure_contract[x11]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_keeps_the_named_display_echo[:0]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_keeps_the_named_display_echo[host:9]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_keeps_the_named_display_echo[machine:22]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_keeps_the_named_display_echo[other:3]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_keeps_the_named_display_echo[unix/:11]", + "eval.tests.test_platform_selection_is_ignored.test_null_platform_override_preserves_the_missing_display_variable_message", + "eval.tests.test_platform_selection_is_ignored.test_offscreen_escape_attempt_still_echoes_the_x11_address[headless]", + "eval.tests.test_platform_selection_is_ignored.test_offscreen_escape_attempt_still_echoes_the_x11_address[null]", + "eval.tests.test_platform_selection_is_ignored.test_offscreen_escape_attempt_still_echoes_the_x11_address[offscreen]", + "eval.tests.test_platform_selection_is_ignored.test_offscreen_escape_attempt_still_echoes_the_x11_address[osmesa]", + "eval.tests.test_platform_selection_is_ignored.test_offscreen_escape_attempt_still_echoes_the_x11_address[wayland]", + "eval.tests.test_platform_selection_is_ignored.test_platform_override_never_leaks_stdout_or_extra_stderr[]", + "eval.tests.test_platform_selection_is_ignored.test_platform_override_never_leaks_stdout_or_extra_stderr[cocoa]", + "eval.tests.test_platform_selection_is_ignored.test_platform_override_never_leaks_stdout_or_extra_stderr[null]", + "eval.tests.test_platform_selection_is_ignored.test_platform_override_never_leaks_stdout_or_extra_stderr[x11]", + "eval.tests.test_platform_selection_is_ignored.test_unset_and_empty_platform_override_are_observationally_identical", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv0]", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv1]", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv2]", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv3]", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv4]", + "eval.tests.test_startup_failure.test_argv_is_ignored[argv5]", + "eval.tests.test_startup_failure.test_exit_due_to_sigsegv_not_clean_return[:8]", + "eval.tests.test_startup_failure.test_exit_due_to_sigsegv_not_clean_return[None]", + "eval.tests.test_startup_failure.test_exit_due_to_sigsegv_not_clean_return[]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:0.3]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:0]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:1024]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:1]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:5]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:7]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:99]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[:abc]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[hostname:12]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[localhost:9]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[unix/:123]", + "eval.tests.test_startup_failure.test_failed_display_address_round_trips_verbatim[unix/:6]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:0.3]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:0]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:1024]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:1]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:5]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:7]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:99]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[:abc]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[None]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[hostname:12]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[localhost:9]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[unix/:123]", + "eval.tests.test_startup_failure.test_glfw_failure_diagnostic_is_exact_and_echoes_display[unix/:6]", + "eval.tests.test_startup_failure.test_missing_display_message_differs_from_unreachable_display", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:0.3]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:0]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:1024]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:1]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:5]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:7]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:99]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[:abc]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[hostname:12]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[localhost:9]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[unix/:123]", + "eval.tests.test_startup_failure.test_stderr_has_exactly_two_diagnostics_lines[unix/:6]", + "eval.tests.test_startup_input_invariants.test_all_three_io_channels_perturbed_simultaneously_leave_output_identical[:99]", + "eval.tests.test_startup_input_invariants.test_all_three_io_channels_perturbed_simultaneously_leave_output_identical[host/0]", + "eval.tests.test_startup_input_invariants.test_all_three_io_channels_perturbed_simultaneously_leave_output_identical[one:1]", + "eval.tests.test_startup_input_invariants.test_all_three_io_channels_perturbed_simultaneously_leave_output_identical[unix/:7]", + "eval.tests.test_startup_input_invariants.test_argv_ignored_even_for_pathological_argument_battery", + "eval.tests.test_startup_input_invariants.test_diagnostic_family_is_byte_deterministic_across_repeated_runs[:0]", + "eval.tests.test_startup_input_invariants.test_diagnostic_family_is_byte_deterministic_across_repeated_runs[None]", + "eval.tests.test_startup_input_invariants.test_diagnostic_family_is_byte_deterministic_across_repeated_runs[]", + "eval.tests.test_startup_input_invariants.test_diagnostic_family_is_byte_deterministic_across_repeated_runs[two spaced]", + "eval.tests.test_startup_input_invariants.test_diagnostic_family_is_byte_deterministic_across_repeated_runs[unix/:2]", + "eval.tests.test_startup_input_invariants.test_internal_and_tab_chars_in_display_echo_verbatim[0 x]", + "eval.tests.test_startup_input_invariants.test_internal_and_tab_chars_in_display_echo_verbatim[a:b c]", + "eval.tests.test_startup_input_invariants.test_internal_and_tab_chars_in_display_echo_verbatim[localhost: 3]", + "eval.tests.test_startup_input_invariants.test_internal_and_tab_chars_in_display_echo_verbatim[unix/:0.0]", + "eval.tests.test_startup_input_invariants.test_internal_and_tab_chars_in_display_echo_verbatim[x\\ty]", + "eval.tests.test_startup_input_invariants.test_unrelated_client_env_vars_do_not_alter_the_startup_contract[extra_env0]", + "eval.tests.test_startup_input_invariants.test_unrelated_client_env_vars_do_not_alter_the_startup_contract[extra_env1]", + "eval.tests.test_startup_input_invariants.test_unrelated_client_env_vars_do_not_alter_the_startup_contract[extra_env2]", + "eval.tests.test_startup_input_invariants.test_unrelated_client_env_vars_do_not_alter_the_startup_contract[extra_env3]", + "eval.tests.test_startup_input_invariants.test_unrelated_client_env_vars_do_not_alter_the_startup_contract[extra_env4]", + "eval.tests.test_startup_input_invariants.test_whitespace_terminal_display_echo_is_byte_preserved[ ]", + "eval.tests.test_startup_input_invariants.test_whitespace_terminal_display_echo_is_byte_preserved[ 9]", + "eval.tests.test_startup_input_invariants.test_whitespace_terminal_display_echo_is_byte_preserved[ ]", + "eval.tests.test_startup_input_invariants.test_whitespace_terminal_display_echo_is_byte_preserved[:0\\t]", + "eval.tests.test_startup_input_invariants.test_whitespace_terminal_display_echo_is_byte_preserved[\\t]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[ /remote]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[%%]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[:+5]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[:-1]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[::]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[:]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[:abc]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[[::1]:2]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[\\t:9]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[host]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[tcp/host:3]", + "eval.tests.test_stdin_is_ignored.test_malformed_addresses_all_map_to_the_single_x11_failure_class[unix/]", + "eval.tests.test_stdin_is_ignored.test_no_stderr_noise_beyond_the_two_fatal_lines_regardless_of_stdin", + "eval.tests.test_stdin_is_ignored.test_stdin_is_never_needed_for_the_single_reachable_display_state", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[ascii_4k]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[assorted_control]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[close]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[del_block]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[empty]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[hello_lines]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[mixed_binary_4k]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[nul_block]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[one_char]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[one_newline]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[pipe_full_ascii]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[pipe_full_nul]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[quit_exit]", + "eval.tests.test_stdin_is_ignored.test_stdin_payload_does_not_change_startup_output[text_with_embedded_nul]" + ] + } + }, + "commit": "eb11109cab39779f70e63df657d000dfc3655120", + "data_source": "synthetic_programgym", + "difficulty": "", + "difficulty_score": null, + "eval_clean_hashes": [ + "c3c1e1b084cfb4c035d82919d14f99a87b152f97b0d7c75db532f72800fff5e3" + ], + "input_record": { + "commit": "eb11109cab39779f70e63df657d000dfc3655120", + "difficulty": "medium", + "difficulty_code_lines": 34444, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 34444, + "difficulty_runtime_deps": 11, + "difficulty_score": 3.6162948266066524, + "difficulty_test_code_lines": 3225, + "full_name": "koide3/iridescence", + "input_joern_zip": "cpp_joern/koide3__iridescence.zip", + "joern_status": true, + "joern_time": 29.421599820954725, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 85, + "similarity": 0.5417783260345459 + }, + { + "pb_fullname": "OSGeo/gdal", + "rank": 196, + "similarity": 0.4810500144958496 + }, + { + "pb_fullname": "OSGeo/PROJ", + "rank": 83, + "similarity": 0.471274197101593 + }, + { + "pb_fullname": "ArthurSonzogni/json-tui", + "rank": 790, + "similarity": 0.4501422345638275 + } + ], + "repo_path": "cpp/koide3__iridescence", + "source": "commit:eb11109cab39779f70e63df657d000dfc3655120", + "status": "done", + "url": "https://github.com/koide3/iridescence" + }, + "instance_id": "koide3__iridescence.eb11109", + "language": "cpp", + "module_iterations": [], + "repository": "koide3/iridescence" +} diff --git a/koide3--iridescence.eb11109/tests/test.sh b/koide3--iridescence.eb11109/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/koide3--iridescence.eb11109/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/koide3--iridescence.eb11109/tests/workspace.tar.gz b/koide3--iridescence.eb11109/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ea8107a0ea2ebab49ec302beebe202dbc135c187 --- /dev/null +++ b/koide3--iridescence.eb11109/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7362b2edbd59af6bd3f518555efaadc0a358b723c16d54df5ae83519b12ed149 +size 1369281 diff --git a/koihik--luaformatter.29afe10/environment/Dockerfile b/koihik--luaformatter.29afe10/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/koihik--luaformatter.29afe10/environment/docker-compose.yaml b/koihik--luaformatter.29afe10/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/koihik--luaformatter.29afe10/environment/download.sh b/koihik--luaformatter.29afe10/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..c566a410a4da80ee1664a719fbf09b2e974f421e --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/download.sh @@ -0,0 +1,87 @@ +#!/usr/bin/env bash +# ProgramGym download stage for LuaFormatter (Koihik__LuaFormatter). +# +# The repository's third_party/ submodule directories (antlr4, yaml-cpp, +# args) are EMPTY in the packaged source tree, but the CMake build requires +# them at build time. The generated ANTLR parser sources in generated/ are +# already committed and do not need regeneration. +# +# This script is standalone and source-safe. It only downloads and unpacks the +# three third-party source archives into an offline cache and exports the +# environment variables that build.sh relies on. It performs NO build, compile, +# link, or test step. It must be valid in shell source mode: +# source /source_ro/download.sh +# It never calls `exit` in normal control flow, never reads any repository +# file, and embeds every URL and version pin explicitly below. + +# ---- default real GCC 13 libstdc++ so configure-time try_run and the final +# ---- binary resolve GLIBCXX 3.4.32 at runtime (the system libstdc++ is 6.0.30) +export LD_LIBRARY_PATH="/opt/gcc-13/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" + +VENDOR_DIR="/opt/vendor" +export VENDOR_DIR + +mkdir -p "$VENDOR_DIR" + +# fetch_and_unpack +# Downloads .tar.gz and unpacks it to $VENDOR_DIR/. +# Idempotent: a marker file marks a completed unpack so re-sourcing is cheap. +fetch_and_unpack() { + local tag="$1" + local dst="$2" + local url="$3" + + local marker="$VENDOR_DIR/$dst/.pb_marker" + if [ -f "$marker" ]; then + return 0 + fi + + local tarball="$VENDOR_DIR/$tag.tar.gz" + local tmpdir="$VENDOR_DIR/.tmp_$tag" + + if curl -fsSL -o "$tarball" "$url"; then + echo "download ok: $url" + else + echo "ERROR: failed to download $url" >&2 + return 1 + fi + + rm -rf "$tmpdir" + mkdir -p "$tmpdir" + if ! tar -xzf "$tarball" -C "$tmpdir"; then + echo "ERROR: failed to unpack $tarball" >&2 + return 1 + fi + + # The single top-level directory of the extracted archive. + local inner + inner="$(find "$tmpdir" -mindepth 1 -maxdepth 1 -type d | head -n 1)" + if [ -z "$inner" ]; then + echo "ERROR: no directory found in $tarball" >&2 + return 1 + fi + + rm -rf "$VENDOR_DIR/$dst" + mv "$inner" "$VENDOR_DIR/$dst" + touch "$marker" + echo "unpacked: $dst" + return 0 +} + +fetch_and_unpack "antlr4-4.7.1" "antlr4" "https://github.com/antlr/antlr4/archive/refs/tags/4.7.1.tar.gz" +fetch_and_unpack "yaml-cpp-0.8.0" "yaml-cpp" "https://github.com/jbeder/yaml-cpp/archive/refs/tags/0.8.0.tar.gz" +fetch_and_unpack "args-6.4.6" "args" "https://github.com/Taywee/args/archive/refs/tags/6.4.6.tar.gz" + +# Fail loudly if sourced but a required archive is still missing. +for d in antlr4 yaml-cpp args; do + if [ ! -f "$VENDOR_DIR/$d/.pb_marker" ]; then + echo "ERROR: third-party source '$d' not available under $VENDOR_DIR" >&2 + if [ -n "${BASH_SOURCE[0]}" ] && [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi + fi +done + +echo "download.sh: third-party sources ready under $VENDOR_DIR" diff --git a/koihik--luaformatter.29afe10/environment/executable b/koihik--luaformatter.29afe10/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..1878ff912f1231b10253a701cd6d0936e39aa303 --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44f4cc7f6db0b591dc774c663fcf0294d99a76413c53ff17e78e4a8a28995988 +size 1754208 diff --git a/koihik--luaformatter.29afe10/environment/harbor_configure_apt_mirror.sh b/koihik--luaformatter.29afe10/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/koihik--luaformatter.29afe10/environment/harbor_prepare_download_env.sh b/koihik--luaformatter.29afe10/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/koihik--luaformatter.29afe10/environment/workspace.tar.gz b/koihik--luaformatter.29afe10/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5817c420bd46eb8ed6299ba17a174d4b73f95159 --- /dev/null +++ b/koihik--luaformatter.29afe10/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f68a15397ee02cfa1f6837364161234069a099339008cf37e2d34ffacb2ec3f7 +size 5655 diff --git a/koihik--luaformatter.29afe10/instruction.md b/koihik--luaformatter.29afe10/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/koihik--luaformatter.29afe10/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/koihik--luaformatter.29afe10/solution/solve.sh b/koihik--luaformatter.29afe10/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/koihik--luaformatter.29afe10/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/koihik--luaformatter.29afe10/task.toml b/koihik--luaformatter.29afe10/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1b3982d800aac8b17312db2ae9a1d40d377a98ed --- /dev/null +++ b/koihik--luaformatter.29afe10/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/koihik--luaformatter.29afe10" +description = "Synthetic ProgramGym cleanroom reconstruction task for Koihik/LuaFormatter" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "Koihik__LuaFormatter.29afe10" +repository = "Koihik/LuaFormatter" +commit = "29afe1046ad015de96ffdb6d361a21882356e801" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.5149460053080044 +test_branches = 5 +test_count = 1465 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/koihik--luaformatter.29afe10/tests/Dockerfile b/koihik--luaformatter.29afe10/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_01.tar.gz b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f90e2215f587113e2f0ca95c988848744a8d0d2d --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1fead6005bb50b25f5b2143f10e068fff8c1a60b71ecaa3380596a7a2ff338f0 +size 18915 diff --git a/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_02.tar.gz b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f692580e7d44dbf8c363be5ca81b0db81f2de25b --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53dedf39af5db7ce418db8e49935d80313f5b0ecbfc87cbdb15c9e1a8a550870 +size 22773 diff --git a/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_03.tar.gz b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..a912fa8c9682c6c894e7b9d4833c8fa23a339502 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad5cc7b460b43ef4840e8615a195da9b6c2b4e169aefc13f20b6b1f182788d2e +size 17847 diff --git a/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_04.tar.gz b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e9d9ff75b5b3f23cc7552f7119b50c031f5b073b --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ac6029ca5bdc26a27b3f1d967cb83d2bd64f576ef0994f35b2afe2f230b18eb +size 32572 diff --git a/koihik--luaformatter.29afe10/tests/blobs/tests/generated_upstream.tar.gz b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f030c29b1b6cce2ddb8e75136ea9d5017e4c8e34 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbeae4da636ef3f89c967209978e171050a501dd139eb32a88582a2e970b4463 +size 18367 diff --git a/koihik--luaformatter.29afe10/tests/docker-compose.yaml b/koihik--luaformatter.29afe10/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/koihik--luaformatter.29afe10/tests/download.sh b/koihik--luaformatter.29afe10/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..c566a410a4da80ee1664a719fbf09b2e974f421e --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/download.sh @@ -0,0 +1,87 @@ +#!/usr/bin/env bash +# ProgramGym download stage for LuaFormatter (Koihik__LuaFormatter). +# +# The repository's third_party/ submodule directories (antlr4, yaml-cpp, +# args) are EMPTY in the packaged source tree, but the CMake build requires +# them at build time. The generated ANTLR parser sources in generated/ are +# already committed and do not need regeneration. +# +# This script is standalone and source-safe. It only downloads and unpacks the +# three third-party source archives into an offline cache and exports the +# environment variables that build.sh relies on. It performs NO build, compile, +# link, or test step. It must be valid in shell source mode: +# source /source_ro/download.sh +# It never calls `exit` in normal control flow, never reads any repository +# file, and embeds every URL and version pin explicitly below. + +# ---- default real GCC 13 libstdc++ so configure-time try_run and the final +# ---- binary resolve GLIBCXX 3.4.32 at runtime (the system libstdc++ is 6.0.30) +export LD_LIBRARY_PATH="/opt/gcc-13/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" + +VENDOR_DIR="/opt/vendor" +export VENDOR_DIR + +mkdir -p "$VENDOR_DIR" + +# fetch_and_unpack +# Downloads .tar.gz and unpacks it to $VENDOR_DIR/. +# Idempotent: a marker file marks a completed unpack so re-sourcing is cheap. +fetch_and_unpack() { + local tag="$1" + local dst="$2" + local url="$3" + + local marker="$VENDOR_DIR/$dst/.pb_marker" + if [ -f "$marker" ]; then + return 0 + fi + + local tarball="$VENDOR_DIR/$tag.tar.gz" + local tmpdir="$VENDOR_DIR/.tmp_$tag" + + if curl -fsSL -o "$tarball" "$url"; then + echo "download ok: $url" + else + echo "ERROR: failed to download $url" >&2 + return 1 + fi + + rm -rf "$tmpdir" + mkdir -p "$tmpdir" + if ! tar -xzf "$tarball" -C "$tmpdir"; then + echo "ERROR: failed to unpack $tarball" >&2 + return 1 + fi + + # The single top-level directory of the extracted archive. + local inner + inner="$(find "$tmpdir" -mindepth 1 -maxdepth 1 -type d | head -n 1)" + if [ -z "$inner" ]; then + echo "ERROR: no directory found in $tarball" >&2 + return 1 + fi + + rm -rf "$VENDOR_DIR/$dst" + mv "$inner" "$VENDOR_DIR/$dst" + touch "$marker" + echo "unpacked: $dst" + return 0 +} + +fetch_and_unpack "antlr4-4.7.1" "antlr4" "https://github.com/antlr/antlr4/archive/refs/tags/4.7.1.tar.gz" +fetch_and_unpack "yaml-cpp-0.8.0" "yaml-cpp" "https://github.com/jbeder/yaml-cpp/archive/refs/tags/0.8.0.tar.gz" +fetch_and_unpack "args-6.4.6" "args" "https://github.com/Taywee/args/archive/refs/tags/6.4.6.tar.gz" + +# Fail loudly if sourced but a required archive is still missing. +for d in antlr4 yaml-cpp args; do + if [ ! -f "$VENDOR_DIR/$d/.pb_marker" ]; then + echo "ERROR: third-party source '$d' not available under $VENDOR_DIR" >&2 + if [ -n "${BASH_SOURCE[0]}" ] && [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi + fi +done + +echo "download.sh: third-party sources ready under $VENDOR_DIR" diff --git a/koihik--luaformatter.29afe10/tests/executable b/koihik--luaformatter.29afe10/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..1878ff912f1231b10253a701cd6d0936e39aa303 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44f4cc7f6db0b591dc774c663fcf0294d99a76413c53ff17e78e4a8a28995988 +size 1754208 diff --git a/koihik--luaformatter.29afe10/tests/harbor_configure_apt_mirror.sh b/koihik--luaformatter.29afe10/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/koihik--luaformatter.29afe10/tests/harbor_prepare_download_env.sh b/koihik--luaformatter.29afe10/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/koihik--luaformatter.29afe10/tests/programgym_evaluator.py b/koihik--luaformatter.29afe10/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/koihik--luaformatter.29afe10/tests/programgym_task.json b/koihik--luaformatter.29afe10/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..e2a8b2fb0fa735d2921f1093eb78096cee2bb174 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/programgym_task.json @@ -0,0 +1,1788 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_formatting_pipeline.test_disable_format_multiple_blocks_preserved_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_formatting_pipeline.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_formatting_pipeline.test_disable_format_single_block_preserved_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_formatting_pipeline.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_argument_parsing.test_double_dash_terminates_flag_parser_positional", + "eval.tests.test_argument_parsing.test_empty_table_sep_value_type_exit_one", + "eval.tests.test_argument_parsing.test_help_exits_before_validation_of_unknown_args", + "eval.tests.test_argument_parsing.test_invalid_table_sep_value_type_exit_one", + "eval.tests.test_argument_parsing.test_missing_value_for_int_value_flag_exit_one", + "eval.tests.test_argument_parsing.test_missing_value_for_string_value_flag_exit_one", + "eval.tests.test_argument_parsing.test_parse_error_prints_help_to_stderr", + "eval.tests.test_argument_parsing.test_parse_error_stdout_stays_empty", + "eval.tests.test_argument_parsing.test_unknown_flag_reports_error_and_exit_one", + "eval.tests.test_argument_parsing.test_unknown_long_flag_with_double_dash_reports_error", + "eval.tests.test_argument_parsing.test_validation_error_at_most_one_group_align_args", + "eval.tests.test_argument_parsing.test_validation_error_at_most_one_group_control_block", + "eval.tests.test_argument_parsing.test_validation_error_at_most_one_group_function_line", + "eval.tests.test_argument_parsing.test_validation_error_at_most_one_group_use_tab", + "eval.tests.test_argument_parsing.test_validation_error_group_break_after_functioncall_lp", + "eval.tests.test_argument_parsing.test_validation_error_group_chop_down_table", + "eval.tests.test_argument_parsing.test_validation_error_group_double_single_quote", + "eval.tests.test_cli_help.test_default_dump_config_matches_golden", + "eval.tests.test_cli_help.test_dump_config_boolean_key_golden", + "eval.tests.test_cli_help.test_dump_config_header_fields_golden", + "eval.tests.test_cli_help.test_dump_config_reflects_config_file_override", + "eval.tests.test_cli_help.test_dump_config_reflects_indent_width_flag_override", + "eval.tests.test_cli_help.test_dump_config_reflects_line_separator_flag", + "eval.tests.test_cli_help.test_dump_config_returns_zero_without_input_files", + "eval.tests.test_cli_help.test_help_footer_seconds_line_explains_double_dash", + "eval.tests.test_cli_help.test_help_lists_representative_option_flags", + "eval.tests.test_cli_help.test_help_long_flag_exits_zero_and_describes_program", + "eval.tests.test_cli_help.test_help_prints_version_footer_last_line", + "eval.tests.test_cli_help.test_help_short_flag_matches_long_help_footer", + "eval.tests.test_cli_help.test_version_does_not_write_to_stderr", + "eval.tests.test_cli_help.test_version_prints_version_and_exits_zero", + "eval.tests.test_cli_help.test_version_short_flag_e_prints_version", + "eval.tests.test_config_discovery.test_command_line_overrides_config_file", + "eval.tests.test_config_discovery.test_config_file_missing_exit_one_and_message", + "eval.tests.test_config_discovery.test_dot_lua_format_auto_discovery_in_cwd", + "eval.tests.test_config_discovery.test_dot_lua_format_discovered_in_parent_dir", + "eval.tests.test_config_discovery.test_explicit_config_beats_auto_discovery", + "eval.tests.test_config_discovery.test_explicit_config_file_controls_style", + "eval.tests.test_config_discovery.test_explicit_config_file_is_used", + "eval.tests.test_config_discovery.test_explicit_config_long_flag_is_used", + "eval.tests.test_config_discovery.test_home_config_discovery", + "eval.tests.test_config_discovery.test_invalid_column_limit_config_aborts", + "eval.tests.test_config_discovery.test_invalid_config_style_value_aborts", + "eval.tests.test_config_discovery.test_no_config_found_prints_default_message", + "eval.tests.test_config_discovery.test_unsupported_config_key_is_ignored", + "eval.tests.test_config_discovery.test_xdg_config_home_discovery", + "eval.tests.test_config_validation_errors.test_readfromfile_conflicting_quote_flags", + "eval.tests.test_config_validation_errors.test_readfromfile_invalid_line_separator_exact_stderr", + "eval.tests.test_config_validation_errors.test_readfromfile_negative_column_limit_exact_stderr", + "eval.tests.test_config_validation_errors.test_readfromfile_negative_indent_width_exact_stderr", + "eval.tests.test_config_validation_errors.test_readfromfile_negative_tab_width_exact_stderr", + "eval.tests.test_config_validation_errors.test_readfrommap_conflicting_quote_flags", + "eval.tests.test_config_validation_errors.test_readfrommap_negative_column_limit_exact_stderr", + "eval.tests.test_file_validation.test_directory_argument_is_not_a_file", + "eval.tests.test_file_validation.test_inplace_read_only_file_no_access_to_write", + "eval.tests.test_file_validation.test_no_read_permission_file_skipped", + "eval.tests.test_file_validation.test_nonexistent_file_reports_no_such_file", + "eval.tests.test_file_validation.test_unusable_file_skipped_others_still_format", + "eval.tests.test_formatting_pipeline.test_check_mode_file_already_formatted_returns_zero", + "eval.tests.test_formatting_pipeline.test_check_mode_file_unformatted_returns_two", + "eval.tests.test_formatting_pipeline.test_check_mode_missing_file_returns_zero", + "eval.tests.test_formatting_pipeline.test_check_mode_stdin_already_formatted_returns_zero", + "eval.tests.test_formatting_pipeline.test_check_mode_stdin_unformatted_returns_two_without_output", + "eval.tests.test_formatting_pipeline.test_disable_format_blocks_from_config_file", + "eval.tests.test_formatting_pipeline.test_disable_format_multiple_blocks_preserved_golden", + "eval.tests.test_formatting_pipeline.test_disable_format_on_without_off_is_passive", + "eval.tests.test_formatting_pipeline.test_disable_format_single_block_preserved_golden", + "eval.tests.test_formatting_pipeline.test_disable_format_unmatched_off_marker_leaves_formatted", + "eval.tests.test_formatting_pipeline.test_disable_format_uses_original_span_not_reformatted", + "eval.tests.test_formatting_pipeline.test_file_argument_formatting_to_stdout", + "eval.tests.test_formatting_pipeline.test_filestdin_batch_mixed_flags", + "eval.tests.test_formatting_pipeline.test_in_place_keeps_disabled_block_verbatim", + "eval.tests.test_formatting_pipeline.test_in_place_rewrites_file", + "eval.tests.test_formatting_pipeline.test_syntax_error_in_file_argument_returns_one", + "eval.tests.test_formatting_pipeline.test_syntax_error_stdin_reports_and_exit_one", + "eval.tests.test_formatting_pipeline.test_syntax_error_stdout_is_empty", + "eval.tests.test_formatting_pipeline.test_syntax_error_unknown_token_stdin_exit_one", + "eval.tests.test_formatting_pipeline.test_unknown_config_style_value_via_cli", + "eval.tests.test_line_separators.test_convert_line_separator_render_crlf_inside_long_string", + "eval.tests.test_line_separators.test_crlf_input_default_line_separator_preserves_crlf", + "eval.tests.test_line_separators.test_line_separator_cr_converts_newlines_to_cr", + "eval.tests.test_line_separators.test_line_separator_crlf_converts_bare_cr_input", + "eval.tests.test_line_separators.test_line_separator_crlf_converts_newlines_to_crlf", + "eval.tests.test_line_separators.test_line_separator_crlf_roundtrips_windowss_crlf_input", + "eval.tests.test_line_separators.test_line_separator_flag_via_config_file", + "eval.tests.test_line_separators.test_line_separator_input_bare_cr_dominant", + "eval.tests.test_line_separators.test_line_separator_input_crlf_dominant", + "eval.tests.test_line_separators.test_line_separator_input_lf_dominant_keeps_lf", + "eval.tests.test_line_separators.test_line_separator_input_mixed_counts_pick_crlf", + "eval.tests.test_line_separators.test_line_separator_input_tie_crlf_and_cr_resolves_crlf", + "eval.tests.test_line_separators.test_line_separator_input_tie_lf_and_crlf_resolves_lf", + "eval.tests.test_line_separators.test_line_separator_lf_converts_bare_cr_input", + "eval.tests.test_line_separators.test_line_separator_lf_preserves_lf", + "eval.tests.test_line_separators.test_line_separator_os_uses_host_lf_on_linux", + "eval.tests.test_pipeline_aggregation.test_check_multiple_files_all_formatted_returns_zero", + "eval.tests.test_pipeline_aggregation.test_check_multiple_files_lists_only_unformatted", + "eval.tests.test_pipeline_aggregation.test_empty_stdin_check_reports_unformatted", + "eval.tests.test_pipeline_aggregation.test_empty_stdin_formats_to_single_newline", + "eval.tests.test_pipeline_aggregation.test_in_place_with_check_prefers_check_and_does_not_rewrite", + "eval.tests.test_pipeline_aggregation.test_single_newline_stdin_is_already_formatted", + "eval.tests.test_style_config_flags.test_cli_flag_overrides_config_file_in_dump", + "eval.tests.test_style_config_flags.test_multiple_style_flags_applied_together", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_args=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_args=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_parameter=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_parameter=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_table_field=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[align_table_field=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_functioncall_lp=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_functioncall_lp=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_functiondef_lp=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_functiondef_lp=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_operator=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_operator=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_table_lb=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_after_table_lb=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_functioncall_rp=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_functioncall_rp=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_functiondef_rp=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_functiondef_rp=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_table_rb=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[break_before_table_rb=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_kv_table=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_kv_table=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_parameter=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_parameter=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_table=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[chop_down_table=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[column_limit=100]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[column_table_limit=25]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[column_table_limit_kv=30]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[continuation_indent_width=6]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[double_quote_to_single_quote=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[double_quote_to_single_quote=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[extra_sep_at_table_end=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[extra_sep_at_table_end=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[keep_simple_control_block_one_line=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[keep_simple_control_block_one_line=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[keep_simple_function_one_line=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[keep_simple_function_one_line=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[line_breaks_after_function_body=2]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[single_quote_to_double_quote=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[single_quote_to_double_quote=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_around_equals_in_field=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_around_equals_in_field=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_before_call=3]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_functioncall_parens=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_functioncall_parens=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_functiondef_parens=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_functiondef_parens=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_table_braces=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[spaces_inside_table_braces=true]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[tab_width=8]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[table_sep=;]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[use_tab=false]", + "eval.tests.test_style_config_flags.test_style_flag_changes_exactly_one_dump_line[use_tab=true]", + "eval.tests.test_style_outcome_flags.test_default_keep_simple_control_block_stays_one_line", + "eval.tests.test_style_outcome_flags.test_default_keep_simple_function_stays_one_line", + "eval.tests.test_style_outcome_flags.test_line_separator_cr_file_route_writes_cr_to_stdout", + "eval.tests.test_style_outcome_flags.test_no_keep_simple_control_block_one_line_forces_break", + "eval.tests.test_style_outcome_flags.test_no_keep_simple_function_one_line_forces_break", + "eval.tests.test_style_outcome_flags.test_use_tab_indents_function_body_with_tabs" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_chop_down_table_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_double_to_single_quote_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_extra_sep_at_table_end_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_no_restrictive_flags_default_one_line_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_cli_flags.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_file_load.TestConfigAffectsFormatting.test_config_file_format_output_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_config_file_load.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_config_file_load.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_file_load.TestConfigAffectsFormatting.test_default_format_output_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_config_file_load.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_config_file_load.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_dump_config.TestDefaultDump.test_default_dump_matches_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_dump_config.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_dump_config.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_dump_config.TestDumpWithConfigFile.test_modified_config_dump_matches_golden", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_dump_config.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_dump_config.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_chop_down_table_golden", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_double_to_single_quote_golden", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_extra_sep_at_table_end_golden", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_indent_width_visible_exact", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_line_separator_crlf_exact_bytes", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_line_separator_default_input", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_no_restrictive_flags_default_one_line_golden", + "eval.tests.test_cli_flags.TestFlagAffectsFormatting.test_single_to_double_quote_exact", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--align-args-align_args-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--align-parameter-align_parameter-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-after-functioncall-lp-break_after_functioncall_lp-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-after-functiondef-lp-break_after_functiondef_lp-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-after-operator-break_after_operator-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-after-table-lb-break_after_table_lb-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-before-functioncall-rp-break_before_functioncall_rp-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--break-before-table-rb-break_before_table_rb-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--chop-down-kv-table-chop_down_kv_table-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--chop-down-parameter-chop_down_parameter-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--extra-sep-at-table-end-extra_sep_at_table_end-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--keep-simple-control-block-one-line-keep_simple_control_block_one_line-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--keep-simple-function-one-line-keep_simple_function_one_line-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-align-args-align_args-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-align-parameter-align_parameter-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-after-functioncall-lp-break_after_functioncall_lp-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-after-functiondef-lp-break_after_functiondef_lp-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-after-operator-break_after_operator-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-after-table-lb-break_after_table_lb-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-before-functioncall-rp-break_before_functioncall_rp-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-break-before-table-rb-break_before_table_rb-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-chop-down-kv-table-chop_down_kv_table-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-chop-down-parameter-chop_down_parameter-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-extra-sep-at-table-end-extra_sep_at_table_end-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-keep-simple-control-block-one-line-keep_simple_control_block_one_line-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-keep-simple-function-one-line-keep_simple_function_one_line-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-spaces-around-equals-in-field-spaces_around_equals_in_field-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-spaces-inside-functioncall-parens-spaces_inside_functioncall_parens-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-spaces-inside-functiondef-parens-spaces_inside_functiondef_parens-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-spaces-inside-table-braces-spaces_inside_table_braces-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--no-use-tab-use_tab-false]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--spaces-around-equals-in-field-spaces_around_equals_in_field-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--spaces-inside-functioncall-parens-spaces_inside_functioncall_parens-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--spaces-inside-functiondef-parens-spaces_inside_functiondef_parens-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--spaces-inside-table-braces-spaces_inside_table_braces-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_boolean_flag_sets_its_key_in_dump[--use-tab-use_tab-true]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_flag_not_given_reports_default", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_opposite_flag_pairs_are_opposite", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--column-limit-column_limit-66-66]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--column-table-limit-column_table_limit-40-40]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--column_table_limit_kv-column_table_limit_kv-25-25]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--continuation-indent-width-continuation_indent_width-9-9]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--indent-width-indent_width-7-7]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--line-breaks-after-function-body-line_breaks_after_function_body-2-2]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--line-separator-line_separator-lf-lf]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--spaces-before-call-spaces_before_call-2-2]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--tab-width-tab_width-3-3]", + "eval.tests.test_cli_flags.TestFlagToConfigMapping.test_value_flag_sets_its_key_in_dump[--table-sep-table_sep-x-x]", + "eval.tests.test_cli_modes.TestCheckMode.test_check_clean_file_returns_zero", + "eval.tests.test_cli_modes.TestCheckMode.test_check_does_not_modify_file", + "eval.tests.test_cli_modes.TestCheckMode.test_check_needs_format_returns_two_and_names_file", + "eval.tests.test_cli_modes.TestCheckMode.test_check_stdin_clean_returns_zero", + "eval.tests.test_cli_modes.TestCheckMode.test_check_stdin_needs_format_returns_two", + "eval.tests.test_cli_modes.TestCheckMode.test_check_verbose_split_exact", + "eval.tests.test_cli_modes.TestFormatOutputInvariants.test_column_limit_forced_wrap_exact", + "eval.tests.test_cli_modes.TestFormatOutputInvariants.test_default_spaces_normalize_long_operators", + "eval.tests.test_cli_modes.TestFormatOutputInvariants.test_indent_width_tab_style_exact", + "eval.tests.test_cli_modes.TestInPlaceMode.test_in_place_honors_config_style", + "eval.tests.test_cli_modes.TestInPlaceMode.test_in_place_multiple_files", + "eval.tests.test_cli_modes.TestInPlaceMode.test_in_place_no_write_permission_error", + "eval.tests.test_cli_modes.TestInPlaceMode.test_in_place_rewrites_file_to_normalized", + "eval.tests.test_cli_modes.TestInPlaceMode.test_in_place_verbose_diagnostic_exact", + "eval.tests.test_cli_modes.TestVerboseFormatting.test_verbose_formatting_diagnostic_and_output", + "eval.tests.test_cli_modes.TestVerboseFormatting.test_verbose_stdin_does_not_print_formatting_line", + "eval.tests.test_cli_modes.TestVersionMode.test_version_flag_exact", + "eval.tests.test_cli_modes.TestVersionMode.test_version_short_flag_exact", + "eval.tests.test_config_discovery.TestExplicitConfigFlag.test_explicit_flag_beats_auto_discovery_exact", + "eval.tests.test_config_discovery.TestLuaFormatAutoDiscovery.test_discovers_dot_lua_format_in_cwd", + "eval.tests.test_config_discovery.TestLuaFormatAutoDiscovery.test_dot_lua_format_in_parent_dir", + "eval.tests.test_config_discovery.TestLuaFormatAutoDiscovery.test_verbose_default_when_no_config_exact", + "eval.tests.test_config_discovery.TestLuaFormatAutoDiscovery.test_verbose_names_auto_discovered_file_exact", + "eval.tests.test_config_discovery.TestXdgAndHomeDiscovery.test_dot_lua_format_takes_precedence_over_xdg", + "eval.tests.test_config_discovery.TestXdgAndHomeDiscovery.test_home_config_discovery_exact", + "eval.tests.test_config_discovery.TestXdgAndHomeDiscovery.test_xdg_config_home_discovery_exact", + "eval.tests.test_config_discovery.TestXdgAndHomeDiscovery.test_xdg_lookup_is_skipped_when_disabled_env", + "eval.tests.test_config_discovery.TestXdgAndHomeDiscovery.test_xdg_takes_precedence_over_home", + "eval.tests.test_config_errors.TestMissingAndNonFileConfig.test_config_is_directory_exits_255", + "eval.tests.test_config_errors.TestMissingAndNonFileConfig.test_config_no_read_permission_exits_255", + "eval.tests.test_config_errors.TestMissingAndNonFileConfig.test_missing_config_file_exits_one", + "eval.tests.test_config_errors.TestYamlConversionFailures.test_malformed_yaml_fails_cleanly", + "eval.tests.test_config_errors.TestYamlConversionFailures.test_valid_partial_map_still_dumps", + "eval.tests.test_config_errors.TestYamlConversionFailures.test_wrong_type_for_character_field", + "eval.tests.test_config_errors.TestYamlConversionFailures.test_wrong_type_for_integer_field", + "eval.tests.test_config_file_load.TestCliOverridesConfigFile.test_flag_overrides_config_file", + "eval.tests.test_config_file_load.TestCliOverridesConfigFile.test_multiple_flags_override_config_exact", + "eval.tests.test_config_file_load.TestConfigAffectsFormatting.test_config_file_format_output_golden", + "eval.tests.test_config_file_load.TestConfigAffectsFormatting.test_default_format_output_golden", + "eval.tests.test_config_file_load.TestConfigAffectsFormatting.test_indent_width_changes_rendering_exact", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_boolean_field", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_character_field", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_integer_field", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_integer_zero_field", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_string_line_separator[cr]", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_string_line_separator[crlf]", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_string_line_separator[input]", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_string_line_separator[lf]", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_load_string_line_separator[os]", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_missing_keys_keep_defaults", + "eval.tests.test_config_file_load.TestReadFromFileHappyPath.test_unknown_keys_ignored", + "eval.tests.test_config_format_effects.TestAggressiveColumnLimit.test_column_limit_one_dump_preserves_value", + "eval.tests.test_config_format_effects.TestAggressiveColumnLimit.test_column_limit_one_wraps_function_exact", + "eval.tests.test_config_format_effects.TestLineSeparatorFromConfigFile.test_cr_via_config_exact_bytes", + "eval.tests.test_config_format_effects.TestLineSeparatorFromConfigFile.test_crlf_via_config_exact_bytes", + "eval.tests.test_config_format_effects.TestLineSeparatorFromConfigFile.test_lf_via_config_exact_bytes", + "eval.tests.test_config_format_effects.TestMalformedButParseableConfig.test_empty_config_file_keeps_defaults", + "eval.tests.test_config_format_effects.TestMalformedButParseableConfig.test_scalar_root_config_is_tolerated", + "eval.tests.test_config_format_effects.TestMalformedButParseableConfig.test_sequence_value_for_integer_field_rejected", + "eval.tests.test_config_format_effects.TestTableSepFromConfigFile.test_table_sep_replace_comma_with_x", + "eval.tests.test_config_format_effects.TestTableSepFromConfigFile.test_table_sep_semicolon_from_config", + "eval.tests.test_config_more_fields.TestConfigFieldDumpSurface.test_many_boolean_fields_dump_exact", + "eval.tests.test_config_more_fields.TestConfigFieldDumpSurface.test_zero_allowed_limits_dump_exact", + "eval.tests.test_config_more_fields.TestConfigRoundTripAllKeys.test_dump_as_config_round_trips_byte_identical", + "eval.tests.test_config_more_fields.TestConfigRoundTripAllKeys.test_round_trip_preserves_33_keys_and_order", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_align_parameter_false_via_config_exact", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_break_after_operator_false_moves_operator_to_next_line", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_break_after_operator_true_keeps_operator_on_line", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_chop_down_kv_table_via_config", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_continuation_indent_changes_dump_value", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_continuation_indent_width_eight_via_config", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_continuation_indent_width_two_via_config", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_keep_simple_function_one_line_false_via_config", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_keep_simple_function_one_line_true_via_config", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_line_breaks_after_function_body_two_blanks", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_spaces_around_equals_in_field_false_removes_padding", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_spaces_around_equals_in_field_true_keeps_padding", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_spaces_inside_table_braces_false_stays_tight", + "eval.tests.test_config_more_fields.TestDistinctConfigFieldFormatEffects.test_spaces_inside_table_braces_true_inserts_padding", + "eval.tests.test_config_validation.TestBooleanValidator.test_boolean_values_accepted[align_args: false\\n-align_args-false]", + "eval.tests.test_config_validation.TestBooleanValidator.test_boolean_values_accepted[align_args: true\\n-align_args-true]", + "eval.tests.test_config_validation.TestBooleanValidator.test_boolean_values_accepted[break_after_operator: true\\n-break_after_operator-true]", + "eval.tests.test_config_validation.TestBooleanValidator.test_boolean_values_accepted[chop_down_kv_table: false\\n-chop_down_kv_table-false]", + "eval.tests.test_config_validation.TestBooleanValidator.test_boolean_values_accepted[spaces_inside_table_braces: true\\n-spaces_inside_table_braces-true]", + "eval.tests.test_config_validation.TestCharacterValidator.test_char_accepted_quoted", + "eval.tests.test_config_validation.TestCharacterValidator.test_character_yaml_style_read", + "eval.tests.test_config_validation.TestIntegerValidator.test_column_limit_negative_rejected", + "eval.tests.test_config_validation.TestIntegerValidator.test_column_limit_positive_accepted[column_limit: 120\\n]", + "eval.tests.test_config_validation.TestIntegerValidator.test_column_limit_positive_accepted[column_limit: 1\\n]", + "eval.tests.test_config_validation.TestIntegerValidator.test_column_limit_positive_accepted[column_limit: 99999\\n]", + "eval.tests.test_config_validation.TestIntegerValidator.test_column_limit_zero_rejected", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_negative_indent_width_rejected", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_negative_zero_allowed_fields_rejected[continuation_indent_width: -1\\n-continuation_indent_width]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_negative_zero_allowed_fields_rejected[spaces_before_call: -2\\n-spaces_before_call]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_other_zero_allowed_fields_accepted[column_table_limit: 0\\n-column_table_limit]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_other_zero_allowed_fields_accepted[column_table_limit_kv: 0\\n-column_table_limit_kv]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_other_zero_allowed_fields_accepted[continuation_indent_width: 0\\n-continuation_indent_width]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_other_zero_allowed_fields_accepted[spaces_before_call: 0\\n-spaces_before_call]", + "eval.tests.test_config_validation.TestIntegerZeroValidator.test_zero_indent_width_accepted", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_all_valid_values_accepted[cr]", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_all_valid_values_accepted[crlf]", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_all_valid_values_accepted[input]", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_all_valid_values_accepted[lf]", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_all_valid_values_accepted[os]", + "eval.tests.test_config_validation.TestLineSeparatorValidator.test_invalid_value_rejected", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_both_false_allowed_and_dumped", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_cli_both_flags_reports_single_to_double", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_conflict_d2s_reports_double_key_when_s2d_first", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_conflict_from_file_then_cli_flag", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_conflict_in_file_d2s_first", + "eval.tests.test_config_validation.TestQuoteConflictValidator.test_one_way_conversion_allowed", + "eval.tests.test_config_validation.TestUseTabTabWidthConflict.test_negative_tab_width_rejected", + "eval.tests.test_config_validation.TestUseTabTabWidthConflict.test_tab_width_zero_then_use_tab_true", + "eval.tests.test_config_validation.TestUseTabTabWidthConflict.test_use_tab_true_without_tab_width_ok", + "eval.tests.test_config_validation.TestUseTabTabWidthConflict.test_use_tab_with_zero_tab_width_rejected", + "eval.tests.test_config_validation.TestUseTabTabWidthConflict.test_zero_tab_width_without_use_tab_accepted", + "eval.tests.test_config_validation.TestValidateThroughCliFlags.test_cli_invalid_column_limit_zero", + "eval.tests.test_config_validation.TestValidateThroughCliFlags.test_cli_invalid_line_separator", + "eval.tests.test_config_validation.TestValidateThroughCliFlags.test_cli_negative_indent_width", + "eval.tests.test_config_validation.TestValidateThroughCliFlags.test_cli_use_tab_zero_tab_width_conflict", + "eval.tests.test_config_validation.TestValidateThroughCliFlags.test_cli_valid_values_dump_exact", + "eval.tests.test_dump_config.TestDefaultDump.test_default_dump_matches_golden", + "eval.tests.test_dump_config.TestDefaultDump.test_default_values_exact", + "eval.tests.test_dump_config.TestDefaultDump.test_dump_contains_all_33_keys", + "eval.tests.test_dump_config.TestDefaultDump.test_dump_exits_zero_with_empty_stderr", + "eval.tests.test_dump_config.TestDefaultDump.test_dump_no_trailing_comment_or_garbage", + "eval.tests.test_dump_config.TestDefaultDump.test_dump_shape_is_plain_key_value_lines", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--align-args-align_args-true]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--extra-sep-at-table-end-extra_sep_at_table_end-true]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--keep-simple-function-one-line-keep_simple_function_one_line-true]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--no-align-args-align_args-false]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--no-break-before-table-rb-break_before_table_rb-false]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--no-keep-simple-control-block-one-line-keep_simple_control_block_one_line-false]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--no-use-tab-use_tab-false]", + "eval.tests.test_dump_config.TestDefaultDump.test_single_flag_reflected_in_dump[--use-tab-use_tab-true]", + "eval.tests.test_dump_config.TestDumpWithConfigFile.test_config_loaded_values_exact", + "eval.tests.test_dump_config.TestDumpWithConfigFile.test_dump_is_deterministic", + "eval.tests.test_dump_config.TestDumpWithConfigFile.test_modified_config_dump_matches_golden", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args0-dump_usetab.golden-use_tab-true]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args1-dump_nousetab.golden-use_tab-false]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args2-dump_d2s.golden-double_quote_to_single_quote-true]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args3-dump_s2d.golden-single_quote_to_double_quote-true]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args4-dump_table.golden-extra_sep_at_table_end-true]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args5-dump_spaces.golden-spaces_inside_table_braces-true]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args6-dump_tablelim.golden-column_table_limit-60]", + "eval.tests.test_dump_config.TestDumpWithFlags.test_flag_group_dump_matches_golden[args7-dump_lbafb.golden-line_breaks_after_function_body-3]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_io.test_check_mode_all_formatted_stdout_empty", + "eval.tests.test_cli_io.test_check_mode_already_formatted_stdout_empty", + "eval.tests.test_cli_io.test_check_mode_multi_file", + "eval.tests.test_cli_io.test_check_mode_needs_formatting_names_file", + "eval.tests.test_cli_io.test_column_limit_cli", + "eval.tests.test_cli_io.test_config_file_applies_exact_golden", + "eval.tests.test_cli_io.test_config_file_missing_exit_one_with_diagnostic", + "eval.tests.test_cli_io.test_config_use_tab_exact_golden", + "eval.tests.test_cli_io.test_dump_config_shows_defaults", + "eval.tests.test_cli_io.test_format_multiple_files_stdout_exact", + "eval.tests.test_cli_io.test_help_exit_zero_exposes_flags", + "eval.tests.test_cli_io.test_indent_width_cli", + "eval.tests.test_cli_io.test_inplace_does_not_echo_stdout", + "eval.tests.test_cli_io.test_inplace_formats_file", + "eval.tests.test_cli_io.test_invalid_flag_error", + "eval.tests.test_cli_io.test_line_separator_cr", + "eval.tests.test_cli_io.test_line_separator_input_crlf", + "eval.tests.test_cli_io.test_line_separator_invalid_exact_diagnostic", + "eval.tests.test_cli_io.test_line_separator_lf", + "eval.tests.test_cli_io.test_missing_file_error", + "eval.tests.test_cli_io.test_syntax_error_returns_nonzero", + "eval.tests.test_cli_io.test_verbose_mode", + "eval.tests.test_cli_io.test_version_flag", + "eval.tests.test_disable_format_golden.test_disable_format_preserves_chained_layout", + "eval.tests.test_disable_format_golden.test_disable_format_preserves_content", + "eval.tests.test_disable_format_golden.test_disable_format_surrounding_still_formatted", + "eval.tests.test_disable_format_golden.test_golden_sample_formatting", + "eval.tests.test_disable_format_golden.test_golden_sample_via_file_argument", + "eval.tests.test_functions.test_break_after_functioncall_lp", + "eval.tests.test_functions.test_break_after_functioncall_lp_without_flag", + "eval.tests.test_functions.test_break_after_functiondef_lp", + "eval.tests.test_functions.test_break_before_functioncall_rp", + "eval.tests.test_functions.test_break_before_functiondef_rp", + "eval.tests.test_functions.test_chained_method_call_break", + "eval.tests.test_functions.test_chained_method_call_one_line", + "eval.tests.test_functions.test_chop_down_parameter", + "eval.tests.test_functions.test_coincident_string_and_table_args", + "eval.tests.test_functions.test_function_body_multiple_stats", + "eval.tests.test_functions.test_function_call_colon_method_break", + "eval.tests.test_functions.test_function_call_empty_parens_comment", + "eval.tests.test_functions.test_function_call_long_args_break", + "eval.tests.test_functions.test_function_call_no_args", + "eval.tests.test_functions.test_function_call_parens", + "eval.tests.test_functions.test_function_call_string_concatenation_args", + "eval.tests.test_functions.test_function_def_param_break_multiline", + "eval.tests.test_functions.test_function_multiline_no_keep", + "eval.tests.test_functions.test_function_one_line[function foo() end\\n-function foo() end\\n]", + "eval.tests.test_functions.test_function_one_line[function foo(...) end\\n-function foo(...) end\\n]", + "eval.tests.test_functions.test_function_one_line[function foo(a) end\\n-function foo(a) end\\n]", + "eval.tests.test_functions.test_function_one_line[function foo(a, ...) end\\n-function foo(a, ...) end\\n]", + "eval.tests.test_functions.test_function_one_line[function foo(a,b) end\\n-function foo(a, b) end\\n]", + "eval.tests.test_functions.test_function_one_line[function foo(a,b,c) end\\n-function foo(a, b, c) end\\n]", + "eval.tests.test_functions.test_function_one_line[local function bar() end\\n-local function bar() end\\n]", + "eval.tests.test_functions.test_function_one_line[local function bar(a) end\\n-local function bar(a) end\\n]", + "eval.tests.test_functions.test_functioncall_args_aligned_break_nested", + "eval.tests.test_functions.test_functiondef_expression", + "eval.tests.test_functions.test_functiondef_expression_body", + "eval.tests.test_functions.test_line_breaks_after_function_body", + "eval.tests.test_functions.test_local_function_return_expression_list", + "eval.tests.test_functions.test_method_call_string_arg", + "eval.tests.test_functions.test_method_call_table_arg", + "eval.tests.test_functions.test_method_definition", + "eval.tests.test_functions.test_name_method_call_with_args", + "eval.tests.test_functions.test_named_function_no_simple_keep", + "eval.tests.test_functions.test_spaces_before_call_default", + "eval.tests.test_functions.test_spaces_before_call_zero", + "eval.tests.test_functions.test_spaces_inside_functioncall_parens", + "eval.tests.test_functions.test_spaces_inside_functiondef_parens", + "eval.tests.test_multiline_comments.test_assignment_expression_with_functiondef", + "eval.tests.test_multiline_comments.test_break_after_operator_contrast", + "eval.tests.test_multiline_comments.test_comment_after_method_name", + "eval.tests.test_multiline_comments.test_comment_after_return_item", + "eval.tests.test_multiline_comments.test_comment_before_if_statement", + "eval.tests.test_multiline_comments.test_comment_between_expression_list_items", + "eval.tests.test_multiline_comments.test_comment_in_kv_table_field", + "eval.tests.test_multiline_comments.test_comment_in_leading_position", + "eval.tests.test_multiline_comments.test_comment_inside_table_field", + "eval.tests.test_multiline_comments.test_concatenated_table_fields", + "eval.tests.test_multiline_comments.test_conditional_comment_prevents_one_line", + "eval.tests.test_multiline_comments.test_explist_long_first_arg_breaks", + "eval.tests.test_multiline_comments.test_function_body_blank_line_preserved_after_statements", + "eval.tests.test_multiline_comments.test_functioncall_args_aligned_default", + "eval.tests.test_multiline_comments.test_goto_and_label_comments", + "eval.tests.test_multiline_comments.test_indexed_assignment_spacing", + "eval.tests.test_multiline_comments.test_local_with_initializer_and_attrib", + "eval.tests.test_multiline_comments.test_long_simple_table_one_line_chops", + "eval.tests.test_multiline_comments.test_multiline_local_decl_break", + "eval.tests.test_multiline_comments.test_multiple_assign_distinct_lines", + "eval.tests.test_multiline_comments.test_multiple_stacked_line_comments", + "eval.tests.test_multiline_comments.test_nested_do_end_multiline", + "eval.tests.test_multiline_comments.test_return_with_comment", + "eval.tests.test_statements_blocks.test_block_variable_assignment_statements", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[do\\nx=1\\nend\\n-do\\n x = 1\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[for i=1,10 do\\nprint(i)\\nend\\n-for i = 1, 10 do\\n print(i)\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[for k,v in pairs(t) do\\nprint(k)\\nend\\n-for k, v in pairs(t) do\\n print(k)\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[if a then\\nx=1\\nend\\n-if a then\\n x = 1\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[repeat\\nx=x+1\\nuntil x>10\\n-repeat\\n x = x + 1\\nuntil x > 10\\n]", + "eval.tests.test_statements_blocks.test_control_block_multiline_no_keep[while a do\\nx=1\\nend\\n-while a do\\n x = 1\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_not_simple_when_multiple_stats", + "eval.tests.test_statements_blocks.test_control_block_one_line[do\\nx=1\\nend\\n-do x = 1 end\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[do\\nx=1\\ny=2\\nend\\n-do\\n x = 1\\n y = 2\\nend\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[for i=1,10 do\\nprint(i)\\nend\\n-for i = 1, 10 do print(i) end\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[for i=1,10,2 do\\nend\\n-for i = 1, 10, 2 do end\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[for k,v in pairs(t) do\\nprint(k)\\nend\\n-for k, v in pairs(t) do print(k) end\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[goto lbl\\n::lbl::\\n-goto lbl\\n::lbl::\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[repeat\\nx=x+1\\nuntil x>10\\n-repeat x = x + 1 until x > 10\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[repeat\\nx=x+1\\ny=y-1\\nuntil x>10\\n-repeat\\n x = x + 1\\n y = y - 1\\nuntil x > 10\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[while a do\\nx=1\\nend\\n-while a do x = 1 end\\n]", + "eval.tests.test_statements_blocks.test_control_block_one_line[while a do\\nx=1\\ny=2\\nend\\n-while a do\\n x = 1\\n y = 2\\nend\\n]", + "eval.tests.test_statements_blocks.test_do_stat_semicolon_in_block", + "eval.tests.test_statements_blocks.test_empty_block_keeps_one_line", + "eval.tests.test_statements_blocks.test_function_block_not_simple_when_multiple_stats", + "eval.tests.test_statements_blocks.test_function_keep_simple_explicit_flag", + "eval.tests.test_statements_blocks.test_goto_with_label", + "eval.tests.test_statements_blocks.test_if_elseif_else_multiline", + "eval.tests.test_statements_blocks.test_if_elseif_multiple", + "eval.tests.test_statements_blocks.test_if_single_line_when_simple", + "eval.tests.test_statements_blocks.test_if_with_else_stays_multiline", + "eval.tests.test_statements_blocks.test_nested_control_blocks_indent", + "eval.tests.test_statements_blocks.test_return_inside_function_multiline", + "eval.tests.test_statements_blocks.test_return_statement[return 1,2,3\\n-return 1, 2, 3\\n]", + "eval.tests.test_statements_blocks.test_return_statement[return 1\\n-return 1\\n]", + "eval.tests.test_statements_blocks.test_return_statement[return;\\n-return;\\n]", + "eval.tests.test_statements_blocks.test_return_statement[return\\n-return\\n0]", + "eval.tests.test_statements_blocks.test_return_statement[return\\n-return\\n1]", + "eval.tests.test_statements_blocks.test_stat_with_semicolons", + "eval.tests.test_statements_blocks.test_while_do_end_multiline_even_one_stat_with_comment", + "eval.tests.test_statements_blocks.test_while_over_column_limit_not_one_line", + "eval.tests.test_strings_comments_operators.test_comment_after_control_keyword", + "eval.tests.test_strings_comments_operators.test_comment_after_while_keyword", + "eval.tests.test_strings_comments_operators.test_crlf_input_kept", + "eval.tests.test_strings_comments_operators.test_double_to_single_quote", + "eval.tests.test_strings_comments_operators.test_double_to_single_re_escapes_inner_quotes", + "eval.tests.test_strings_comments_operators.test_inline_comment_block_disables_one_line", + "eval.tests.test_strings_comments_operators.test_line_comment_after_statement", + "eval.tests.test_strings_comments_operators.test_line_comment_already_blank_kept", + "eval.tests.test_strings_comments_operators.test_long_table_comment_break", + "eval.tests.test_strings_comments_operators.test_multiline_long_string_preserved", + "eval.tests.test_strings_comments_operators.test_operator_break_after_operator_default", + "eval.tests.test_strings_comments_operators.test_operator_break_within_limit", + "eval.tests.test_strings_comments_operators.test_quote_conversion_conflict_rejected", + "eval.tests.test_strings_comments_operators.test_shebang_preserved", + "eval.tests.test_strings_comments_operators.test_single_to_double_quote", + "eval.tests.test_strings_comments_operators.test_strings_default[local s=\"hi\"\\n-local s = \"hi\"\\n]", + "eval.tests.test_strings_comments_operators.test_strings_default[local s='hi'\\n-local s = 'hi'\\n]", + "eval.tests.test_strings_comments_operators.test_strings_default[local s=[==[raw]==]\\n-local s = [==[raw]==]\\n]", + "eval.tests.test_strings_comments_operators.test_strings_default[local s=[[raw]]\\n-local s = [[raw]]\\n]", + "eval.tests.test_strings_comments_operators.test_top_level_block_comment", + "eval.tests.test_tables.test_break_before_table_rb", + "eval.tests.test_tables.test_column_table_limit_independent_of_column_limit", + "eval.tests.test_tables.test_column_table_limit_kv", + "eval.tests.test_tables.test_empty_table_spaces_inside_braces_keeps_empty", + "eval.tests.test_tables.test_empty_table_with_comment_line_keeps_newline", + "eval.tests.test_tables.test_kv_no_chop_via_config", + "eval.tests.test_tables.test_kv_table_chop_down", + "eval.tests.test_tables.test_table_align_field_continuation", + "eval.tests.test_tables.test_table_chop_with_extra_sep_rb", + "eval.tests.test_tables.test_table_column_limit_break", + "eval.tests.test_tables.test_table_column_limit_follows_column_limit", + "eval.tests.test_tables.test_table_default_no_extra_sep", + "eval.tests.test_tables.test_table_extra_sep_at_table_end", + "eval.tests.test_tables.test_table_multiline_layout", + "eval.tests.test_tables.test_table_no_break_after_lb", + "eval.tests.test_tables.test_table_no_break_after_lb_uses_column_zero", + "eval.tests.test_tables.test_table_no_spaces_around_equals", + "eval.tests.test_tables.test_table_one_line[local m={{1},{1,2}}\\n-local m = {{1}, {1, 2}}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={1,2,3}\\n-local t = {1, 2, 3}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={[1]=10,[2]=20}\\n-local t = {[1] = 10, [2] = 20}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={a=1,b=2}\\n-local t = {a = 1, b = 2}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={func()}\\n-local t = {func()}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={obj:method(1)}\\n-local t = {obj:method(1)}\\n]", + "eval.tests.test_tables.test_table_one_line[local t={}\\n-local t = {}\\n]", + "eval.tests.test_tables.test_table_proxy_var_break_no_break_lb", + "eval.tests.test_tables.test_table_semicolon_separator", + "eval.tests.test_tables.test_table_spaces_inside_braces", + "eval.tests.test_tables.test_table_string_key", + "eval.tests.test_var_suffix_chains.test_chained_call_semicolon_breaks_and_pops_indent", + "eval.tests.test_var_suffix_chains.test_chained_method_call_continuation_indent", + "eval.tests.test_var_suffix_chains.test_chained_var_in_varlist", + "eval.tests.test_var_suffix_chains.test_chained_var_no_break_after_operator", + "eval.tests.test_var_suffix_chains.test_chained_var_suffix_comment_preserved", + "eval.tests.test_var_suffix_chains.test_comment_after_var_name_before_suffix", + "eval.tests.test_var_suffix_chains.test_deep_parenthesized_var_in_assign", + "eval.tests.test_var_suffix_chains.test_function_call_statement_semicolon", + "eval.tests.test_var_suffix_chains.test_function_call_statement_semicolon_string_arg", + "eval.tests.test_var_suffix_chains.test_function_call_statement_semicolon_with_args", + "eval.tests.test_var_suffix_chains.test_indexed_member_var_break", + "eval.tests.test_var_suffix_chains.test_long_string_key_then_method_call", + "eval.tests.test_var_suffix_chains.test_long_string_multi_level_key_keeps_spacing", + "eval.tests.test_var_suffix_chains.test_long_string_table_key_keeps_interior_spacing", + "eval.tests.test_var_suffix_chains.test_member_dot_break_in_assignment", + "eval.tests.test_var_suffix_chains.test_method_chain_member_colon_break", + "eval.tests.test_var_suffix_chains.test_method_chain_no_break_stays_one_line", + "eval.tests.test_var_suffix_chains.test_method_result_field_assignment", + "eval.tests.test_var_suffix_chains.test_method_then_member_field_no_extra_indent", + "eval.tests.test_var_suffix_chains.test_parenthesized_expression_local_var", + "eval.tests.test_var_suffix_chains.test_parenthesized_functioncall_var", + "eval.tests.test_var_suffix_chains.test_parenthesized_return_value_statement", + "eval.tests.test_var_suffix_chains.test_parenthesized_var_column_limit_break", + "eval.tests.test_var_suffix_chains.test_parenthesized_var_index_suffix", + "eval.tests.test_var_suffix_chains.test_parenthesized_var_method_suffix", + "eval.tests.test_var_suffix_chains.test_parenthesized_var_multi_suffix", + "eval.tests.test_var_suffix_chains.test_parenthesized_var_suffix", + "eval.tests.test_var_suffix_chains.test_prefixexp_chained_call_break", + "eval.tests.test_var_suffix_chains.test_self_member_colon_method_break", + "eval.tests.test_variables_expressions.test_assignment_chained_index", + "eval.tests.test_variables_expressions.test_assignment_member", + "eval.tests.test_variables_expressions.test_assignment_semicolon", + "eval.tests.test_variables_expressions.test_binary_operators[local x=(1+2)*3\\n-local x = (1 + 2) * 3\\n]", + "eval.tests.test_variables_expressions.test_binary_operators[local x=(1==2)\\n-local x = (1 == 2)\\n]", + "eval.tests.test_variables_expressions.test_binary_operators[local x=1 .. 2\\n-local x = 1 .. 2\\n]", + "eval.tests.test_variables_expressions.test_binary_operators[local x=1+2+3+4\\n-local x = 1 + 2 + 3 + 4\\n]", + "eval.tests.test_variables_expressions.test_binary_operators[local x=a and b or c\\n-local x = a and b or c\\n]", + "eval.tests.test_variables_expressions.test_binary_operators[local x=a*b+c/d\\n-local x = a * b + c / d\\n]", + "eval.tests.test_variables_expressions.test_concatenation_and_literal", + "eval.tests.test_variables_expressions.test_index_expressions[local x=t[1][2]\\n-local x = t[1][2]\\n]", + "eval.tests.test_variables_expressions.test_index_expressions[local x=t[1]\\n-local x = t[1]\\n]", + "eval.tests.test_variables_expressions.test_index_expressions[local x=t[foo]\\n-local x = t[foo]\\n]", + "eval.tests.test_variables_expressions.test_index_expressions[local x=t[key][sub]\\n-local x = t[key][sub]\\n]", + "eval.tests.test_variables_expressions.test_local_assign_semicolon", + "eval.tests.test_variables_expressions.test_local_var_semicolon", + "eval.tests.test_variables_expressions.test_long_literals", + "eval.tests.test_variables_expressions.test_numeric_literal_spacing", + "eval.tests.test_variables_expressions.test_operator_associativity_precedence", + "eval.tests.test_variables_expressions.test_parenthesized_expression", + "eval.tests.test_variables_expressions.test_unary_operators[local n=#t\\n-local n = #t\\n]", + "eval.tests.test_variables_expressions.test_unary_operators[local x=- -5\\n-local x = - -5\\n]", + "eval.tests.test_variables_expressions.test_unary_operators[local x=-5\\n-local x = -5\\n]", + "eval.tests.test_variables_expressions.test_unary_operators[local y=not a\\n-local y = not a\\n]", + "eval.tests.test_variables_expressions.test_unary_operators[local y=~a\\n-local y = ~a\\n]", + "eval.tests.test_variables_expressions.test_var_or_exp_parenthesized", + "eval.tests.test_variables_expressions.test_var_suffix_chained_index_and_member", + "eval.tests.test_variables_expressions.test_variable_declarations[a,b,c=1,2,3\\n-a, b, c = 1, 2, 3\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[a,b=2,3\\n-a, b = 2, 3\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[a=1\\n-a = 1\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a, b = 1, 2\\n-local a, b = 1, 2\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a,b,c=1,2,3\\n-local a, b, c = 1, 2, 3\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a,b=1,2\\n-local a, b = 1, 2\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a,b\\n-local a, b\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a=1\\n-local a = 1\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local a\\n-local a\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local x = io.open('f')\\n-local x = io.open('f')\\n]", + "eval.tests.test_variables_expressions.test_variable_declarations[local x = 5\\n-local x = 5\\n]", + "eval.tests.test_visitor_chain_blocks.test_blank_line_between_statements_preserved", + "eval.tests.test_visitor_chain_blocks.test_chained_assign_target_next_is_index", + "eval.tests.test_visitor_chain_blocks.test_comment_before_multi_line_stat_then_return", + "eval.tests.test_visitor_chain_blocks.test_comment_before_semicolon_statement", + "eval.tests.test_visitor_chain_blocks.test_comment_between_assign_and_function_statement", + "eval.tests.test_visitor_chain_blocks.test_comment_between_semicolon_statements", + "eval.tests.test_visitor_chain_blocks.test_comment_then_blank_then_return", + "eval.tests.test_visitor_chain_blocks.test_comments_dos_endian_kept_one_line", + "eval.tests.test_visitor_chain_blocks.test_deep_member_break_inside_table_assignment", + "eval.tests.test_visitor_chain_blocks.test_functioncall_statement_chain_fold", + "eval.tests.test_visitor_chain_blocks.test_index_then_member_then_call_fold", + "eval.tests.test_visitor_chain_blocks.test_local_chain_colon_method_break_then_arg", + "eval.tests.test_visitor_chain_blocks.test_local_chained_member_fold", + "eval.tests.test_visitor_chain_blocks.test_local_index_member_chain_fold", + "eval.tests.test_visitor_chain_blocks.test_local_method_then_member_chain_fold", + "eval.tests.test_visitor_chain_blocks.test_member_break_then_string_index", + "eval.tests.test_visitor_chain_blocks.test_member_call_then_member_call_fold", + "eval.tests.test_visitor_chain_blocks.test_return_with_comment_forces_multiline_function", + "eval.tests.test_visitor_chain_blocks.test_self_member_chain_colon_call_fold", + "eval.tests.test_visitor_chain_blocks.test_semicolon_only_empty_stat_in_block", + "eval.tests.test_visitor_chain_blocks.test_semicolon_stat_trailing_comment_before_return", + "eval.tests.test_visitor_chain_blocks.test_semicolon_stat_trailing_comment_in_multiline_block", + "eval.tests.test_visitor_chain_blocks.test_semicolon_then_multiline_block_statement", + "eval.tests.test_visitor_chain_blocks.test_short_chain_under_limit_stays_inline", + "eval.tests.test_visitor_chain_blocks.test_statement_trailing_comment_inside_function", + "eval.tests.test_visitor_chain_blocks.test_two_statements_trailing_comments_before_return", + "eval.tests.test_visitor_chain_blocks.test_varlist_chain_assignment_target_breaks", + "eval.tests.test_visitor_chain_blocks.test_varlist_chain_multiple_assignment_targets", + "eval.tests.test_visitor_chain_blocks.test_varlist_indexated_chain_assignment_target", + "eval.tests.test_visitor_chain_blocks.test_varlist_single_indexated_chain_assignment_target" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_reachability.test_dump_config_defaults", + "eval.tests.test_cli_reachability.test_format_is_idempotent", + "eval.tests.test_cli_reachability.test_format_output_is_stable_across_runs", + "eval.tests.test_cli_reachability.test_help_exits_zero", + "eval.tests.test_cli_reachability.test_long_help_exits_zero", + "eval.tests.test_cli_reachability.test_stdin_plus_file_arg_ignores_stdin", + "eval.tests.test_cli_reachability.test_unknown_flag_exits_nonzero", + "eval.tests.test_cli_reachability.test_version_exits_zero", + "eval.tests.test_comments_shebang.test_comment_before_statement", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[empty_block_comment_before_code]", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[line_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[long_block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[multiline_block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_code_tokens_preserved[trailing_line_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_only_chunk_emitted_verbatim", + "eval.tests.test_comments_shebang.test_comment_text_preserved[block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[comment-only_chunk]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[empty_block_comment_before_code]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[line_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[long_block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[multiline_block_comment_preserved]", + "eval.tests.test_comments_shebang.test_comment_text_preserved[trailing_line_comment_preserved]", + "eval.tests.test_comments_shebang.test_midfile_shebang_is_syntax_error", + "eval.tests.test_comments_shebang.test_second_shebang_is_syntax_error", + "eval.tests.test_comments_shebang.test_shebang_consumes_rest_of_line", + "eval.tests.test_comments_shebang.test_valid_shebang_crlf", + "eval.tests.test_comments_shebang.test_valid_shebang_first_line", + "eval.tests.test_expressions.test_anonymous_function_in_call", + "eval.tests.test_expressions.test_defective_expressions_rejected[bitwise_not_with_no_operand]", + "eval.tests.test_expressions.test_defective_expressions_rejected[concat_of_vararg_with_nothing]", + "eval.tests.test_expressions.test_defective_expressions_rejected[empty_index_brackets]", + "eval.tests.test_expressions.test_defective_expressions_rejected[empty_parentheses_is_not_an_expression]", + "eval.tests.test_expressions.test_defective_expressions_rejected[length_operator_with_no_operand]", + "eval.tests.test_expressions.test_defective_expressions_rejected[not_with_no_operand]", + "eval.tests.test_expressions.test_defective_expressions_rejected[unary_operator_with_no_operand]", + "eval.tests.test_expressions.test_defective_expressions_rejected[unsupported_ternary_punctuation]", + "eval.tests.test_expressions.test_parenthesized_prefixexp", + "eval.tests.test_expressions.test_string_concat_roundtrip", + "eval.tests.test_expressions.test_unary_and_literal_expressions[bitwise_not_unary_op]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[false_literal]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[length_applied_to_negated_expression]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[length_in_return_statement]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[length_unary_op]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[minus_then_minus]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[nil_literal]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[positive_integer_literal_by_itself]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[stacked_unary_operators]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[true_literal]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[unary_minus_on_number]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[unary_not_on_literal]", + "eval.tests.test_expressions.test_unary_and_literal_expressions[vararg_used_as_expression]", + "eval.tests.test_expressions.test_var_suffix_chained_index_dot", + "eval.tests.test_expressions.test_var_suffix_dot", + "eval.tests.test_expressions.test_var_suffix_index", + "eval.tests.test_file_io.test_check_already_formatted_exit_zero", + "eval.tests.test_file_io.test_check_syntax_error_exit_one", + "eval.tests.test_file_io.test_check_would_format_exit_two", + "eval.tests.test_file_io.test_file_format_to_stdout", + "eval.tests.test_file_io.test_file_syntax_error_no_stdout", + "eval.tests.test_file_io.test_inplace_rewrites_file", + "eval.tests.test_file_io.test_stdin_vs_file_agree_on_invalid", + "eval.tests.test_file_io.test_valid_file_roundtrip_parses", + "eval.tests.test_golden_outputs.test_golden_multiple_stray_chars_diagnostic", + "eval.tests.test_golden_outputs.test_golden_nested_if_else_output", + "eval.tests.test_integration.test_all_link_operators_in_one_expression", + "eval.tests.test_integration.test_all_literals_in_one_chunk", + "eval.tests.test_integration.test_formatted_program_reparses", + "eval.tests.test_integration.test_realistic_program_parses[const_attribute_with_function_definition]", + "eval.tests.test_integration.test_realistic_program_parses[control-flow_statements_all_in_one_chunk]", + "eval.tests.test_integration.test_realistic_program_parses[if-elseif-else_classification]", + "eval.tests.test_integration.test_realistic_program_parses[module_metatable_with_vararg]", + "eval.tests.test_integration.test_realistic_program_parses[nested_table_constructors_with_mixed_field_kinds]", + "eval.tests.test_integration.test_realistic_program_parses[numeric_and_generic_for_loops]", + "eval.tests.test_lexer_lexical.test_invalid_number_literals[0x_followed_by_a_non-hex_letter]", + "eval.tests.test_lexer_lexical.test_invalid_number_literals[bare_0x_with_no_hex_digits]", + "eval.tests.test_lexer_lexical.test_invalid_number_literals[bare_dot_is_not_a_number]", + "eval.tests.test_lexer_lexical.test_invalid_number_literals[binary_literal_is_not_part_of_the_grammar]", + "eval.tests.test_lexer_lexical.test_invalid_number_literals[exponent_with_no_digits]", + "eval.tests.test_lexer_lexical.test_invalid_string_literals[mismatched_long-string_delimiters]", + "eval.tests.test_lexer_lexical.test_invalid_string_literals[unknown_escape_sequence]", + "eval.tests.test_lexer_lexical.test_invalid_string_literals[unterminated_double-quoted_string]", + "eval.tests.test_lexer_lexical.test_invalid_string_literals[unterminated_single-quoted_string]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[decimal_float_(FLOAT)]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[decimal_integer_(INT)]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[exponent_minus_sign]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[exponent_plus_sign]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[fractional_with_exponent]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[hex_float_fraction]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[hex_float_integer_mantissa_(HEX_FLOAT)]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[hex_float_leading_dot]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[hex_mixed_case]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[hex_uppercase_(HEX)]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[integer_exponent]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[leading-dot_float]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[leading-dot_with_exponent]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[leading-zero_int]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[long_hex]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[three-digit_int]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[trailing-dot_float]", + "eval.tests.test_lexer_lexical.test_valid_number_literals[zero]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[common_escape_sequences]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[decimal_escape_seq]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[double-quoted_normal_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[empty_double-quoted_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[empty_long_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[empty_single-quoted_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[escaped_backslash]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[escaped_newline]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[escaped_quote_in_normal_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[escaped_single_quote_inside_double_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[hex_escape_seq]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[long_string_with_equal_signs]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[long_string_with_two_equals]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[multiline_long_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[single-quoted_char_string]", + "eval.tests.test_lexer_lexical.test_valid_string_literals[utf8_escape_seq]", + "eval.tests.test_lexer_locations_and_collapse.test_comment_boundary_forms[a_trailing_line_comment_keeps_the_single-statement_body_expa]", + "eval.tests.test_lexer_locations_and_collapse.test_comment_boundary_forms[a_triple-dash_LINE_COMMENT_keeps_its_full_text_before_follow]", + "eval.tests.test_lexer_locations_and_collapse.test_comment_boundary_forms[an_empty_block_comment_with_interior_spaces]", + "eval.tests.test_lexer_locations_and_collapse.test_comment_boundary_forms[block_comments_around_code_on_one_line_plus_a_following_stat]", + "eval.tests.test_lexer_locations_and_collapse.test_comment_boundary_forms[strays_on_a_comment-free_first_line_do_not_disturb_the_valid]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_0]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_10]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_11]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_12]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_13]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_14]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_15]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_16]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_1]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_2]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_3]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_4]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_5]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_6]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_7]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_8]", + "eval.tests.test_lexer_locations_and_collapse.test_new_valid_sources_are_fixed_points[loc_fp_9]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[an_if/else_with_one_statement_per_branch_stays_multi-line_(t]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[do_block_with_a_single_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[function_with_a_single_return_collapses_to_one_line]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[if_with_a_single-statement_then-block]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[numeric_for_with_a_single_statement_collapses]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[repeat/until_with_a_single_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_single_statement_body_collapses_to_one_line[while_with_a_single_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_statement_lead_negatives[a_bare_'#'_(not_a_shebang)_cannot_begin_a_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_statement_lead_negatives[a_bare_unary_minus_cannot_begin_a_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_statement_lead_negatives[a_doubled_'='_is_not_a_valid_expression_chain]", + "eval.tests.test_lexer_locations_and_collapse.test_statement_lead_negatives[two_adjacent_names_are_not_a_valid_statement]", + "eval.tests.test_lexer_locations_and_collapse.test_token_recognition_exact_locations[leading_spaces_shift_'@'_to_offset_13_and_the_block_still_fo]", + "eval.tests.test_lexer_locations_and_collapse.test_token_recognition_exact_locations[stray_after_a_long_NAME_is_reported_at_its_exact_0-based_off]", + "eval.tests.test_lexer_locations_and_collapse.test_token_recognition_exact_locations[stray_on_the_third_line_is_reported_at_line_3_offset_6]", + "eval.tests.test_lexer_locations_and_collapse.test_token_recognition_exact_locations[three_strays_on_one_line_are_reported_at_offsets_0,_2,_4_in_]", + "eval.tests.test_lexer_locations_and_collapse.test_token_recognition_exact_locations[two_adjacent_strays_on_line_two_are_reported_at_offsets_0_an]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[call_result_followed_by_more_call_suffixes]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[deep_index/dot/method_call_chain]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[method_with_table_then_string_argument]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[nested_table_containing_a_function]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[parenthesized_exp_used_as_an_indexed_assignment_target]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[parenthesized_prefix_with_index/dot_suffix]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[table_fields_whose_values_and_keys_are_calls]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[table_value_is_an_anonymous_function]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[table_whose_bare_fields_end_in_a_call]", + "eval.tests.test_lexer_parser_edges.test_call_and_suffix_chains[three-level_index_then_dot_assignment_target]", + "eval.tests.test_lexer_parser_edges.test_control_char_is_token_recognition_error", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[do_block_with_one_statement]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[function_returning_an_anonymous_function]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[if_with_an_empty_elseif_branch]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[if_with_an_empty_then_branch_and_else]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[numeric_for_with_empty_body]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[repeat_nested_inside_numeric_for]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[repeat_nested_inside_while]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[repeat_with_empty_body_and_bare_until]", + "eval.tests.test_lexer_parser_edges.test_control_structure_bodies[while_with_empty_body]", + "eval.tests.test_lexer_parser_edges.test_multiple_stray_chars_exact_diagnostics", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_0]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_10]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_11]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_12]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_13]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_14]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_15]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_16]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_17]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_18]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_19]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_1]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_20]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_21]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_22]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_23]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_24]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_25]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_26]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_27]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_28]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_29]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_2]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_30]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_31]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_32]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_33]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_34]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_35]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_36]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_37]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_38]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_39]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_3]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_40]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_41]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_42]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_43]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_44]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_45]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_46]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_47]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_48]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_49]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_4]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_50]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_51]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_52]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_53]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_54]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_5]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_6]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_7]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_8]", + "eval.tests.test_lexer_parser_edges.test_new_construct_edges_are_fixed_points[fp_edge_9]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[exponent_with_leading_zeros]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[fraction_with_empty_digit_tail_removed_elsewhere]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[hex_fraction_with_no_exponent_part]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[hex_literal_for_zero]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[leading-dot_hex_fraction_with_signed_exponent]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[leading-dot_mantissa_with_zero_exponent]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[leading-zero_mantissa_with_exponent]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[uppercase_0X_leading-dot_hex_float]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[uppercase_E_exponent,_no_sign]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[uppercase_E_exponent_with_minus]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[uppercase_E_exponent_with_plus]", + "eval.tests.test_lexer_parser_edges.test_number_case_and_exponent_boundaries[uppercase_P_exponent_in_hex_float]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[comparison_chain_joined_by_and]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[left-assoc_concat_chain]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[nested_parenthesized_arithmetic]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[parenthesized_unary-not_of_a_disjunction]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[unary_minus_feeding_exponentiation]", + "eval.tests.test_lexer_parser_edges.test_operator_and_unary_edge_chains[unary_not_feeding_an_equality]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[call-result_chain_is_not_a_valid_prefixe]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[local_declaration_after_a_return]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[long-comment_closer_with_wrong_equals_le]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[parenthesized_expression_cannot_be_an_as]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[parenthesized_field_cannot_head_a_varlis]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[statement_after_a_return_inside_a_block]", + "eval.tests.test_lexer_parser_edges.test_parser_negative_edges[unterminated_long_string_with_an_interio]", + "eval.tests.test_lexer_parser_edges.test_repeated_stray_char_columns_incremented", + "eval.tests.test_lexer_parser_edges.test_statement_forms[goto_plus_two_consecutive_labels]", + "eval.tests.test_lexer_parser_edges.test_statement_forms[interspersed_bare_semicolon_between_statements]", + "eval.tests.test_lexer_parser_edges.test_statement_forms[local_function_with_vararg-only_parlist]", + "eval.tests.test_lexer_parser_edges.test_statement_forms[parlist_of_names_then_vararg]", + "eval.tests.test_lexer_parser_edges.test_statement_forms[return_of_call_then_literal_in_one_explist]", + "eval.tests.test_lexer_parser_edges.test_statement_forms[return_of_two_function-call_values]", + "eval.tests.test_lexer_parser_edges.test_stray_before_eof_reports_second_line", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[backslash-z_skip-to-newline_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[bell/backspace/formfeed/vtab_escapes]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[hex_escape_for_NUL]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[single-digit_decimal_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[three-digit_decimal_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[three-digit_decimal_escape_at_the_255_boundary]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[three-digit_decimal_escape_past_the_2_lead_range]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[two-digit-with-leading-zero_decimal_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[two-digit_decimal_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[two-digit_decimal_escape_with_leading_zero]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[utf8_escape_at_unicode_max]", + "eval.tests.test_lexer_parser_edges.test_string_escape_boundary_forms[utf8_escape_with_many_hex_digits]", + "eval.tests.test_lexer_parser_edges.test_string_escape_malformed_forms_rejected[single_hex_digit_is_not_a_valid_\\\\x_escape]", + "eval.tests.test_lexer_parser_edges.test_string_escape_malformed_forms_rejected[utf8_escape_with_a_non-hex_digit]", + "eval.tests.test_lexer_parser_edges.test_string_escape_malformed_forms_rejected[utf8_escape_with_no_hex_digits]", + "eval.tests.test_lexer_parser_edges.test_two_distinct_stray_chars_reported_in_order", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[binary_operator_whose_operand_subsumes_an_anonymous_function]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[call_whose_arguments_are_a_function_and_a_table]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[concat_whose_right_side_is_a_method_call]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[dotted_funcname_with_two_dots]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[method_call_then_immediate_call]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[parenthesized_qualified_call_feeding_two_calls_then_an_index]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[swap_assignment_via_a_multi-receiver_varlist]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[three_receivers_from_a_three-call_explist]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[triple_chained_immediate_calls]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_call_result_chaining_and_multi_receiver[two_receivers_from_one_call]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[a_label_before_any_statement_in_a_chunk]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[forward_goto_then_a_second_forward_goto]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[goto_past_an_unrelated_label_to_a_later_one]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[two_labels_in_a_row_with_gotos_that_cross_the_label_list]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[two_labels_on_one_line_re-emitted_on_separate_lines]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_goto_and_label_orderings[vararg-only_anonymous_function_wrapping_its_args_in_a_table]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[anonymous_function_with_two_statements_and_a_return_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[do_block_with_a_two-statement_body_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[generic_for_with_a_two-statement_body_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[if_with_a_two-statement_then-block_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[named_function_with_local_and_return_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[numeric_for_with_a_three-statement_body_expands_to_indented_]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[repeat/until_with_a_two-statement_body_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_multi_statement_body_expands_to_lines[while_with_a_two-statement_body_expands]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_0]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_10]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_11]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_12]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_13]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_14]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_15]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_16]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_17]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_18]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_19]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_1]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_20]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_21]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_22]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_23]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_24]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_25]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_26]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_27]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_28]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_29]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_2]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_30]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_31]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_32]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_33]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_34]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_35]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_36]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_37]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_38]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_39]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_3]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_4]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_5]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_6]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_7]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_8]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_multi_line_sources_are_fixed_points[ml_fp_9]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[a_bare_colon_is_not_a_valid_statement_separator]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[a_doubled_trailing_field_separator_is_extraneous]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[a_second_name_attribute_after_a_first_is_a_syntax_error]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[a_table_key_containing_an_'='_leaves_the_field_unterminated]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[an_assignment_with_a_dangling_newline_before_EOF_needs_an_ex]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[an_empty_long_string_keyed_in_an_expression_field_fails_to_p]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[an_extra_end_after_a_return-close_is_extraneous]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_new_parser_negative_forms[two_equals_in_a_row_are_not_a_valid_comparison]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[bitwise-not_of_a_negated_hex_literal]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[length_of_a_negated_operand_then_exponent]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[length_operator_applied_directly_to_a_table_literal]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[minus_of_length_feeding_a_plus]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[minus_of_the_length_of_an_empty_table]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[not_applied_to_a_length_expression]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[not_applied_to_a_parenthesized_expression]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_stacked_unary_operator_expressions[three_consecutive_unary_nots]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[anonymous_function_used_as_a_bracketed_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[concat-expression_bracketed_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[empty_table_used_as_a_bracketed_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[expression_mixing_a_number_and_a_table_used_as_a_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[length-expression_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[logical-not_expression_key]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[name_key_mapping_to_an_empty_table]", + "eval.tests.test_lexer_parser_multiline_and_keys.test_table_keys_with_exotic_expressions[unary-minus_numeric_key]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[local_$x_=_1]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[local_a_=_1\\n$]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[local_a_=_1\\nlocal_b_=_2\\n@]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[local_a_=_1_?]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[x_=_1\\n@_y_=_2]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[x_=_1_?]", + "eval.tests.test_lexer_token_recognition_breadth.test_removable_stray_exit_zero[x_=_1____$]", + "eval.tests.test_lexer_token_recognition_breadth.test_stray_in_comment_yields_no_diagnostic", + "eval.tests.test_lexer_token_recognition_breadth.test_token_splitting_stray_exit_one[?_=_1]", + "eval.tests.test_lexer_token_recognition_breadth.test_token_splitting_stray_exit_one[a$b_=_1]", + "eval.tests.test_lexer_token_recognition_breadth.test_token_splitting_stray_exit_one[x_=_a_@_b]", + "eval.tests.test_lexer_token_recognition_breadth.test_token_splitting_stray_exit_one[x_=_a`b]", + "eval.tests.test_lexer_token_recognition_breadth.test_token_splitting_stray_exit_one[x_=_y!z]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[a_string_arg_followed_by_a_table_arg]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[empty-paren_call-result_then_an_immediate_call]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[method_colon_string_arg_then_table_arg]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[method_string_arg_then_parenthesized_arg]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[two_consecutive_string-literal_args]", + "eval.tests.test_name_and_args_chains.test_chained_name_and_args[two_consecutive_table-constructor_args]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_0]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_10]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_1]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_2]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_3]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_4]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_5]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_6]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_7]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_8]", + "eval.tests.test_name_and_args_chains.test_new_arg_sources_are_fixed_points[arg_fp_9]", + "eval.tests.test_name_and_args_chains.test_statement_separation_forms[a_\\\\z_line_continuation_joins_two_string_literals_that_surviv]", + "eval.tests.test_name_and_args_chains.test_statement_separation_forms[a_concat_with_no_surrounding_spaces_round-trips]", + "eval.tests.test_name_and_args_chains.test_statement_separation_forms[call_statements_using_string/table_args_on_separate_lines]", + "eval.tests.test_name_and_args_chains.test_statement_separation_forms[three_semicolon-separated_assignments_each_land_on_their_own]", + "eval.tests.test_name_and_args_chains.test_statement_separation_forms[two_call_statements_separated_by_a_newline]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[..._eq_1]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[::eq_x]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[a_.._b_eq_1]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[a_eq_1_:_2]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[a_eq_1_eq_2]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[a_eq_b_eq_c]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[do_end_extra]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[f(a,b]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[for_i_1,_10_do_end]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[for_i_eq_1,_2,,_3_do_end]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[function_f(,_)_end]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[goto]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[if_x_then_return_end_end]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[if_x_then_then_end]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[local_a,b_eq_1,]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[local_t_eq_{[]_eq_1}]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[local_t_eq_{aeq1,;}]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[local_x_<_eq_1]", + "eval.tests.test_parser_error_recovery_diagnostics.test_exact_parser_recovery_diagnostic[local_x_> 2]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local q = {[x] = 1, [\"y\"] = 2, z = 3, 4, 5}]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local s = (\"a\" .. \"b\") .. (\"c\" .. \"d\")]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local t = {a = {x = 1, y = 2}, b = {3, 4}, {5, 6}}]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local t = {}\\nfor i = 1, 3 do t[i] = i * i end\\nreturn t]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local verylongname1, verylongname2, verylongname3 = f()]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[local x = (a.b):c(1)(2)[3].d]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[obj:method(1, 2):chain().field = 1]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[print(\"a\", \"b\", \"c\", \"d\")]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[repeat x = x + 1 until x > 10;\\nreturn x]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[repeat\\n x = x + 1\\n y = y + x\\nuntil x > 100]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[t:x().y:z()]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[while n > 0 do\\n print(n)\\n n = n - 1\\nend]", + "eval.tests.test_valid_structure_formats.test_valid_program_formats_exactly[while true do\\n x = x + 1\\n if x > 10 then break en]", + "eval.tests.test_valid_structure_formats.test_valid_program_second_format_is_idempotent" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_config_cli.test_break_after_operator_flag", + "eval.tests.test_config_cli.test_chop_down_parameter_flag", + "eval.tests.test_config_cli.test_column_limit_flag", + "eval.tests.test_config_cli.test_config_from_file_oracle[1.lua-format]", + "eval.tests.test_config_cli.test_config_from_file_oracle[2.lua-format]", + "eval.tests.test_config_cli.test_correct_config_accepts_file", + "eval.tests.test_config_cli.test_dump_config_prints_defaults", + "eval.tests.test_config_cli.test_extra_sep_at_table_end_flag", + "eval.tests.test_config_cli.test_functioncall_align_and_break_flags", + "eval.tests.test_config_cli.test_functiondef_layout_flags[align_parameter]", + "eval.tests.test_config_cli.test_functiondef_layout_flags[break_after_functiondef_lp]", + "eval.tests.test_config_cli.test_functiondef_layout_flags[break_before_functiondef_rp]", + "eval.tests.test_config_cli.test_indent_width_flag", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[column_limit]", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[column_table_limit]", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[indent_width]", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[line_separator]", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[single_to_double]", + "eval.tests.test_config_cli.test_invalid_config_errors_on_stderr_exit1[tab]", + "eval.tests.test_config_cli.test_keep_simple_function_one_line_flag", + "eval.tests.test_config_cli.test_line_separator_flag[cr]", + "eval.tests.test_config_cli.test_line_separator_flag[crlf]", + "eval.tests.test_config_cli.test_line_separator_flag[lf]", + "eval.tests.test_config_cli.test_line_separator_input_detects_cr", + "eval.tests.test_config_cli.test_lua_format_auto_discovery_in_working_directory", + "eval.tests.test_config_cli.test_nonexistent_config_file_fails", + "eval.tests.test_config_cli.test_spaces_around_equals_in_field_flag", + "eval.tests.test_config_cli.test_spaces_before_call_flag", + "eval.tests.test_config_cli.test_spaces_inside_functiondef_parens_flag", + "eval.tests.test_config_cli.test_table_align_and_break_flags", + "eval.tests.test_config_cli.test_table_sep_flag", + "eval.tests.test_config_cli.test_use_tab_flag", + "eval.tests.test_config_cli.test_version_flag", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-attrib]", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-function]", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-in_args]", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-space]", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-table]", + "eval.tests.test_format_file.test_format_file_is_idempotent[comment-varlist]", + "eval.tests.test_format_file.test_format_file_is_idempotent[disable_format-simple]", + "eval.tests.test_format_file.test_format_file_is_idempotent[disable_format-with_indent]", + "eval.tests.test_format_file.test_format_file_is_idempotent[expression-function_1]", + "eval.tests.test_format_file.test_format_file_is_idempotent[expression-function_2]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-PR-100]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-PR-108]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-PR-181]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-104]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-144]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-156]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-162]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-168]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-186]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-18]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-19]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-1]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-36]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-62_1]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-62_2]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-62_3]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-70]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-80]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-98]", + "eval.tests.test_format_file.test_format_file_is_idempotent[issues-issue-98_1]", + "eval.tests.test_format_file.test_format_file_is_idempotent[keep_simple_block_one_line-default]", + "eval.tests.test_format_file.test_format_file_is_idempotent[keep_simple_block_one_line-keep_simple_control_block_one_line_false]", + "eval.tests.test_format_file.test_format_file_is_idempotent[keep_simple_block_one_line-keep_simple_function_one_line_false]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-args_length]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-chained_call_args]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-disable_align_in_function]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-functioncall]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-functiondef]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-indent_in_explist]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-long_var]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-nested_method_call]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-operators]", + "eval.tests.test_format_file.test_format_file_is_idempotent[linebreak-table]", + "eval.tests.test_format_file.test_format_file_is_idempotent[literals-doublequote]", + "eval.tests.test_format_file.test_format_file_is_idempotent[literals-singlequote]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-function]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-function_call]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-inner_spaces]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-operator]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-semi]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-shebang]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-statements]", + "eval.tests.test_format_file.test_format_file_is_idempotent[statement-table]", + "eval.tests.test_format_file.test_format_file_is_idempotent[syntax-lua54]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-attrib]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-function]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-in_args]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-space]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-table]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[comment-varlist]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[disable_format-simple]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[disable_format-with_indent]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[expression-function_1]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[expression-function_2]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-PR-100]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-PR-108]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-PR-181]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-104]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-144]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-156]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-162]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-168]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-186]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-18]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-19]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-1]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-36]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-62_1]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-62_2]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-62_3]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-70]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-80]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-98]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[issues-issue-98_1]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[keep_simple_block_one_line-default]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[keep_simple_block_one_line-keep_simple_control_block_one_line_false]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[keep_simple_block_one_line-keep_simple_function_one_line_false]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-args_length]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-chained_call_args]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-disable_align_in_function]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-functioncall]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-functiondef]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-indent_in_explist]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-long_var]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-nested_method_call]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-operators]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[linebreak-table]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[literals-doublequote]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[literals-singlequote]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-function]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-function_call]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-inner_spaces]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-operator]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-semi]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-shebang]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-statements]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[statement-table]", + "eval.tests.test_format_file.test_format_file_matches_upstream_golden[syntax-lua54]", + "eval.tests.test_parser_cli.test_shebang_at_start_is_accepted", + "eval.tests.test_parser_cli.test_wrong_shebang_reports_syntax_error" + ] + } + }, + "commit": "29afe1046ad015de96ffdb6d361a21882356e801", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.5149460053080044, + "eval_clean_hashes": [ + "44f4cc7f6db0b591dc774c663fcf0294d99a76413c53ff17e78e4a8a28995988" + ], + "input_record": { + "commit": "29afe1046ad015de96ffdb6d361a21882356e801", + "difficulty": "easy", + "difficulty_code_lines": 3273, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 3273, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.5149460053080044, + "difficulty_test_code_lines": 1026, + "full_name": "Koihik/LuaFormatter", + "input_joern_zip": "cpp_joern/Koihik__LuaFormatter.zip", + "joern_status": true, + "joern_time": 11.168137050932273, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "ArthurSonzogni/json-tui", + "rank": 673, + "similarity": 0.4573439061641693 + } + ], + "repo_path": "cpp/Koihik__LuaFormatter", + "source": "commit:29afe1046ad015de96ffdb6d361a21882356e801", + "status": "done", + "url": "https://github.com/Koihik/LuaFormatter" + }, + "instance_id": "Koihik__LuaFormatter.29afe10", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 3, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 2, + "branch_name": "generated_upstream", + "iteration_limit": 5, + "module_index": 5, + "module_kind": "tests", + "termination_reason": "module_coverage_threshold_reached" + } + ], + "repository": "Koihik/LuaFormatter" +} diff --git a/koihik--luaformatter.29afe10/tests/test.sh b/koihik--luaformatter.29afe10/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/koihik--luaformatter.29afe10/tests/workspace.tar.gz b/koihik--luaformatter.29afe10/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5817c420bd46eb8ed6299ba17a174d4b73f95159 --- /dev/null +++ b/koihik--luaformatter.29afe10/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f68a15397ee02cfa1f6837364161234069a099339008cf37e2d34ffacb2ec3f7 +size 5655 diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/Dockerfile b/kokkos--kokkos-kernels.4a10bcb/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/docker-compose.yaml b/kokkos--kokkos-kernels.4a10bcb/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/download.sh b/kokkos--kokkos-kernels.4a10bcb/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfde724b9a61298c439eebc42423bbb2312fd4f8 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/download.sh @@ -0,0 +1,100 @@ +#!/usr/bin/env bash +# +# download.sh for kokkos/kokkos-kernels (ProgramGym build stage 1 - networked). +# +# This script is SOURCED, not executed: `source /source_ro/download.sh`. It must be +# safe to source from the repository root, keep exported variables in the current +# shell, avoid relying on positional arguments, and never use `exit` in normal +# control flow. +# +# It downloads and prepares the Kokkos dependency source tree used by build.sh and +# exports the environment variables build.sh relies on. It never compiles, links, +# tests, or otherwise builds anything. +# +# This script is fully standalone: during the download stage only its own file is +# present in the container. It does not read, or branch on, any repository +# dependency/build-config file. All versions, URLs, and dependency information +# are inline. + +# --------------------------------------------------------------------------- +# Failure handling when sourced vs. executed. +# --------------------------------------------------------------------------- +pb_download_bail() { + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# --------------------------------------------------------------------------- +# Persistent dependency location (shared with the offline build stage). +# build.sh expects the Kokkos source tree under $PB_KOKKOS_DEPS_DIR. +# --------------------------------------------------------------------------- +PB_KOKKOS_DEPS_DIR="/workspace/kokkos_deps" +PB_KOKKOS_VERSION="5.1.0" +PB_KOKKOS_TARBALL="${PB_KOKKOS_DEPS_DIR}/kokkos-${PB_KOKKOS_VERSION}.tar.gz" +PB_KOKKOS_SRC_DIR="${PB_KOKKOS_DEPS_DIR}/kokkos-src" + +export PB_KOKKOS_DEPS_DIR +export PB_KOKKOS_VERSION +export PB_KOKKOS_TARBALL +export PB_KOKKOS_SRC_DIR + +# The base image already provides g++ (GCC 13.3) and cmake (3.31.12) on PATH, and +# KokkosKernels requires only a host compiler for the Serial-backend build, so no +# additional toolchain setup is required here. cmake is a single-binary tool and +# needs no extra dev packages for the non-libpthread scenario used in this build. + +# --------------------------------------------------------------------------- +# cURL is present in the base image. Download and extract the pinned Kokkos source +# tarball into the shared dependency directory. All URLs and versions are inline. +# --------------------------------------------------------------------------- +mkdir -p "${PB_KOKKOS_DEPS_DIR}" + +if [ -d "${PB_KOKKOS_SRC_DIR}" ]; then + echo "Kokkos source already present at ${PB_KOKKOS_SRC_DIR}; skipping download." +else + if [ ! -f "${PB_KOKKOS_TARBALL}" ]; then + echo "Downloading Kokkos ${PB_KOKKOS_VERSION} source tarball..." + curl -fSL \ + "https://github.com/kokkos/kokkos/archive/refs/tags/${PB_KOKKOS_VERSION}.tar.gz" \ + -o "${PB_KOKKOS_TARBALL}" + PB_CURL_RC=$? + if [ "${PB_CURL_RC}" -ne 0 ]; then + echo "ERROR: failed to download Kokkos tarball (rc=${PB_CURL_RC})." >&2 + pb_download_bail + fi + else + echo "Kokkos tarball already present at ${PB_KOKKOS_TARBALL}; reusing it." + fi + + echo "Extracting Kokkos source tree..." + PB_EXTRACT_TMP="${PB_KOKKOS_DEPS_DIR}/extract_tmp" + mkdir -p "${PB_EXTRACT_TMP}" + tar -xzf "${PB_KOKKOS_TARBALL}" -C "${PB_EXTRACT_TMP}" + PB_TAR_RC=$? + if [ "${PB_TAR_RC}" -ne 0 ]; then + echo "ERROR: failed to extract Kokkos tarball (rc=${PB_TAR_RC})." >&2 + pb_download_bail + fi + + PB_EXTRACTED_DIR="${PB_EXTRACT_TMP}/kokkos-${PB_KOKKOS_VERSION}" + if [ -d "${PB_EXTRACTED_DIR}" ]; then + mv "${PB_EXTRACTED_DIR}" "${PB_KOKKOS_SRC_DIR}" + else + echo "ERROR: expected extracted directory kokkos-${PB_KOKKOS_VERSION} not found." >&2 + pb_download_bail + fi + + rmdir "${PB_EXTRACT_TMP}" + + # Verify the extraction result without reading any repository file: the source + # directory must now exist at the shared location. + if [ ! -d "${PB_KOKKOS_SRC_DIR}" ]; then + echo "ERROR: Kokkos source tree was not prepared at ${PB_KOKKOS_SRC_DIR}." >&2 + pb_download_bail + fi +fi + +echo "download.sh complete. Kokkos source at ${PB_KOKKOS_SRC_DIR}" diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/executable b/kokkos--kokkos-kernels.4a10bcb/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..a91a61faca31efb9d92e830cd2fe406118de152e --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dcf0f851d42b166003bb1e93e6a5f8741fae0bd481a02d24f8129dbb6d0acb89 +size 470368 diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/harbor_configure_apt_mirror.sh b/kokkos--kokkos-kernels.4a10bcb/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/harbor_prepare_download_env.sh b/kokkos--kokkos-kernels.4a10bcb/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kokkos--kokkos-kernels.4a10bcb/environment/workspace.tar.gz b/kokkos--kokkos-kernels.4a10bcb/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..de0b8b0c0121d795bc915a47ff548dee962203e8 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a86beece3f698b5c705bf779e6385056052273ee9260313bd46edb9aa13190eb +size 11505 diff --git a/kokkos--kokkos-kernels.4a10bcb/instruction.md b/kokkos--kokkos-kernels.4a10bcb/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kokkos--kokkos-kernels.4a10bcb/solution/solve.sh b/kokkos--kokkos-kernels.4a10bcb/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kokkos--kokkos-kernels.4a10bcb/task.toml b/kokkos--kokkos-kernels.4a10bcb/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..aa2a52a4277dfc09102f99b9a9eaafb99b9fc357 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kokkos--kokkos-kernels.4a10bcb" +description = "Synthetic ProgramGym cleanroom reconstruction task for kokkos/kokkos-kernels" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kokkos__kokkos-kernels.4a10bcb" +repository = "kokkos/kokkos-kernels" +commit = "4a10bcb94acb1ead8094d520f3040e5dd99f0c17" +language = "cpp" +difficulty = "unknown" +difficulty_score = 0.0 +test_branches = 6 +test_count = 1542 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/Dockerfile b/kokkos--kokkos-kernels.4a10bcb/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_01.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..a58e50186b792a633a3c548806dca6119c0c6b38 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46310e6842e81aea43c7c9d7f2694c3c8c4e822fe36473e41247494b6e25847b +size 18239 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_02.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..007d0c4ddaf1c13ae47bf5da1a27c4d24ebce814 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a8279983db9ba8bb7a31e59d1b018c12c2878ad6b21895d51492e7fa7e5bb3d4 +size 42792 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_03.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8ee36df2a0ec493bf2c261ac8760bf63fb2ab993 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36337bfc143f5b11d146857ea409af01a7eea9a0992c0afae13daf903d28be58 +size 20693 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_04.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..977db377d808bcdf8b11fe6967c10d5dbffd41df --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2846443e99560715078d42c1632ec6e656adff590eda1703a442b02b5094e59 +size 26925 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_05.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_05.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3cd6dc00edc78078c014abba5ef45be06dc81864 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_05.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:748ea229e4925ff0eb46faceef804a0d4936dc1e74d708ff6070ab32756d2ef1 +size 25272 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_06.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_06.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8c04218d6f930c2e07639eea5151cc38743c6a98 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/blobs/tests/generated_module_06.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b7f7c208c8165a7b826d2a37fcbb01b6fbf60cc59b7fa800471d2774d53cc0d +size 19618 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/docker-compose.yaml b/kokkos--kokkos-kernels.4a10bcb/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/download.sh b/kokkos--kokkos-kernels.4a10bcb/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfde724b9a61298c439eebc42423bbb2312fd4f8 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/download.sh @@ -0,0 +1,100 @@ +#!/usr/bin/env bash +# +# download.sh for kokkos/kokkos-kernels (ProgramGym build stage 1 - networked). +# +# This script is SOURCED, not executed: `source /source_ro/download.sh`. It must be +# safe to source from the repository root, keep exported variables in the current +# shell, avoid relying on positional arguments, and never use `exit` in normal +# control flow. +# +# It downloads and prepares the Kokkos dependency source tree used by build.sh and +# exports the environment variables build.sh relies on. It never compiles, links, +# tests, or otherwise builds anything. +# +# This script is fully standalone: during the download stage only its own file is +# present in the container. It does not read, or branch on, any repository +# dependency/build-config file. All versions, URLs, and dependency information +# are inline. + +# --------------------------------------------------------------------------- +# Failure handling when sourced vs. executed. +# --------------------------------------------------------------------------- +pb_download_bail() { + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# --------------------------------------------------------------------------- +# Persistent dependency location (shared with the offline build stage). +# build.sh expects the Kokkos source tree under $PB_KOKKOS_DEPS_DIR. +# --------------------------------------------------------------------------- +PB_KOKKOS_DEPS_DIR="/workspace/kokkos_deps" +PB_KOKKOS_VERSION="5.1.0" +PB_KOKKOS_TARBALL="${PB_KOKKOS_DEPS_DIR}/kokkos-${PB_KOKKOS_VERSION}.tar.gz" +PB_KOKKOS_SRC_DIR="${PB_KOKKOS_DEPS_DIR}/kokkos-src" + +export PB_KOKKOS_DEPS_DIR +export PB_KOKKOS_VERSION +export PB_KOKKOS_TARBALL +export PB_KOKKOS_SRC_DIR + +# The base image already provides g++ (GCC 13.3) and cmake (3.31.12) on PATH, and +# KokkosKernels requires only a host compiler for the Serial-backend build, so no +# additional toolchain setup is required here. cmake is a single-binary tool and +# needs no extra dev packages for the non-libpthread scenario used in this build. + +# --------------------------------------------------------------------------- +# cURL is present in the base image. Download and extract the pinned Kokkos source +# tarball into the shared dependency directory. All URLs and versions are inline. +# --------------------------------------------------------------------------- +mkdir -p "${PB_KOKKOS_DEPS_DIR}" + +if [ -d "${PB_KOKKOS_SRC_DIR}" ]; then + echo "Kokkos source already present at ${PB_KOKKOS_SRC_DIR}; skipping download." +else + if [ ! -f "${PB_KOKKOS_TARBALL}" ]; then + echo "Downloading Kokkos ${PB_KOKKOS_VERSION} source tarball..." + curl -fSL \ + "https://github.com/kokkos/kokkos/archive/refs/tags/${PB_KOKKOS_VERSION}.tar.gz" \ + -o "${PB_KOKKOS_TARBALL}" + PB_CURL_RC=$? + if [ "${PB_CURL_RC}" -ne 0 ]; then + echo "ERROR: failed to download Kokkos tarball (rc=${PB_CURL_RC})." >&2 + pb_download_bail + fi + else + echo "Kokkos tarball already present at ${PB_KOKKOS_TARBALL}; reusing it." + fi + + echo "Extracting Kokkos source tree..." + PB_EXTRACT_TMP="${PB_KOKKOS_DEPS_DIR}/extract_tmp" + mkdir -p "${PB_EXTRACT_TMP}" + tar -xzf "${PB_KOKKOS_TARBALL}" -C "${PB_EXTRACT_TMP}" + PB_TAR_RC=$? + if [ "${PB_TAR_RC}" -ne 0 ]; then + echo "ERROR: failed to extract Kokkos tarball (rc=${PB_TAR_RC})." >&2 + pb_download_bail + fi + + PB_EXTRACTED_DIR="${PB_EXTRACT_TMP}/kokkos-${PB_KOKKOS_VERSION}" + if [ -d "${PB_EXTRACTED_DIR}" ]; then + mv "${PB_EXTRACTED_DIR}" "${PB_KOKKOS_SRC_DIR}" + else + echo "ERROR: expected extracted directory kokkos-${PB_KOKKOS_VERSION} not found." >&2 + pb_download_bail + fi + + rmdir "${PB_EXTRACT_TMP}" + + # Verify the extraction result without reading any repository file: the source + # directory must now exist at the shared location. + if [ ! -d "${PB_KOKKOS_SRC_DIR}" ]; then + echo "ERROR: Kokkos source tree was not prepared at ${PB_KOKKOS_SRC_DIR}." >&2 + pb_download_bail + fi +fi + +echo "download.sh complete. Kokkos source at ${PB_KOKKOS_SRC_DIR}" diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/executable b/kokkos--kokkos-kernels.4a10bcb/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..a91a61faca31efb9d92e830cd2fe406118de152e --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dcf0f851d42b166003bb1e93e6a5f8741fae0bd481a02d24f8129dbb6d0acb89 +size 470368 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/harbor_configure_apt_mirror.sh b/kokkos--kokkos-kernels.4a10bcb/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/harbor_prepare_download_env.sh b/kokkos--kokkos-kernels.4a10bcb/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/programgym_evaluator.py b/kokkos--kokkos-kernels.4a10bcb/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/programgym_task.json b/kokkos--kokkos-kernels.4a10bcb/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..a4daa796cce24b48dd3e16501f2036c3f18d4126 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/programgym_task.json @@ -0,0 +1,1674 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_boundaries.test_each_group_reports_each_element_independently", + "eval.tests.test_boundaries.test_exact_block_layout_with_trailing_blank_lines[2]", + "eval.tests.test_boundaries.test_exact_block_layout_with_trailing_blank_lines[3]", + "eval.tests.test_boundaries.test_exact_block_layout_with_trailing_blank_lines[5]", + "eval.tests.test_boundaries.test_exact_block_layout_with_trailing_blank_lines[8]", + "eval.tests.test_boundaries.test_fixed_seed_makes_relative_errors_repeatable", + "eval.tests.test_boundaries.test_larger_n_has_matching_element_count[16]", + "eval.tests.test_boundaries.test_larger_n_has_matching_element_count[2]", + "eval.tests.test_boundaries.test_larger_n_has_matching_element_count[4]", + "eval.tests.test_boundaries.test_larger_n_has_matching_element_count[64]", + "eval.tests.test_boundaries.test_n_one_emits_a_single_relative_error", + "eval.tests.test_boundaries.test_n_zero_succeeds_with_no_relative_errors", + "eval.tests.test_boundaries.test_runtime_headers_interleave_with_error_blocks", + "eval.tests.test_boundaries.test_zero_n_keeps_three_runtime_lines", + "eval.tests.test_cli_validation.test_atoi_leading_plus_sign_is_decimal[+0-0]", + "eval.tests.test_cli_validation.test_atoi_leading_plus_sign_is_decimal[+12-12]", + "eval.tests.test_cli_validation.test_atoi_leading_plus_sign_is_decimal[+5-5]", + "eval.tests.test_cli_validation.test_atoi_leading_whitespace_then_digit[ 5-5]", + "eval.tests.test_cli_validation.test_atoi_leading_whitespace_then_digit[ 12x-12]", + "eval.tests.test_cli_validation.test_atoi_leading_whitespace_then_digit[\\t8 y-8]", + "eval.tests.test_cli_validation.test_atoi_leading_zeros_are_decimal_digits[00000-0]", + "eval.tests.test_cli_validation.test_atoi_leading_zeros_are_decimal_digits[0005-5]", + "eval.tests.test_cli_validation.test_atoi_leading_zeros_are_decimal_digits[007-7]", + "eval.tests.test_cli_validation.test_atoi_negative_zero_is_zero[ -0-0]", + "eval.tests.test_cli_validation.test_atoi_negative_zero_is_zero[-0-0]", + "eval.tests.test_cli_validation.test_atoi_negative_zero_is_zero[-00-0]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[0X20]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[0x10]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[0x]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[ff]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[inf]", + "eval.tests.test_cli_validation.test_atoi_non_decimal_and_word_ns_are_zero[nan]", + "eval.tests.test_cli_validation.test_atoi_numeric_prefix_semantics[03-3]", + "eval.tests.test_cli_validation.test_atoi_numeric_prefix_semantics[0junk-0]", + "eval.tests.test_cli_validation.test_atoi_numeric_prefix_semantics[100xyz-100]", + "eval.tests.test_cli_validation.test_atoi_numeric_prefix_semantics[12abc-12]", + "eval.tests.test_cli_validation.test_atoi_numeric_prefix_semantics[8jp-8]", + "eval.tests.test_cli_validation.test_negative_n_allocates_huge_view_and_segfaults[-10]", + "eval.tests.test_cli_validation.test_negative_n_allocates_huge_view_and_segfaults[-1]", + "eval.tests.test_cli_validation.test_negative_n_allocates_huge_view_and_segfaults[-3]", + "eval.tests.test_cli_validation.test_non_numeric_n_is_parsed_as_zero[!!]", + "eval.tests.test_cli_validation.test_non_numeric_n_is_parsed_as_zero[--]", + "eval.tests.test_cli_validation.test_non_numeric_n_is_parsed_as_zero[]", + "eval.tests.test_cli_validation.test_non_numeric_n_is_parsed_as_zero[abc]", + "eval.tests.test_cli_validation.test_non_numeric_n_is_parsed_as_zero[xyz]", + "eval.tests.test_cli_validation.test_single_argument_dereferences_missing_argv2[-0]", + "eval.tests.test_cli_validation.test_single_argument_dereferences_missing_argv2[0]", + "eval.tests.test_cli_validation.test_single_argument_dereferences_missing_argv2[1]", + "eval.tests.test_cli_validation.test_single_argument_dereferences_missing_argv2[28]", + "eval.tests.test_cli_validation.test_single_argument_dereferences_missing_argv2[5]", + "eval.tests.test_cli_validation.test_third_argument_is_ignored[--flag]", + "eval.tests.test_cli_validation.test_third_argument_is_ignored[1]", + "eval.tests.test_cli_validation.test_third_argument_is_ignored[extra]", + "eval.tests.test_cli_validation.test_third_argument_is_ignored[junk]", + "eval.tests.test_cli_validation.test_whitespace_only_n_is_zero", + "eval.tests.test_cli_validation.test_zero_args_exit_code_is_exactly_one", + "eval.tests.test_cli_validation.test_zero_args_prints_exact_usage_message", + "eval.tests.test_cli_validation.test_zero_args_usage_mentions_both_known_argument_names", + "eval.tests.test_cli_validation.test_zero_args_usage_writes_nothing_to_stderr", + "eval.tests.test_golden_output.test_all_three_groups_match_relerr_golden[3]", + "eval.tests.test_golden_output.test_all_three_groups_match_relerr_golden[5]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[16]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[1]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[2]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[32]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[3]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[4]", + "eval.tests.test_golden_output.test_full_normalized_stdout_matches_golden[8]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[16]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[1]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[2]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[32]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[3]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[4]", + "eval.tests.test_golden_output.test_golden_files_are_not_written_at_runtime[8]", + "eval.tests.test_golden_output.test_relative_error_values_match_golden[3]", + "eval.tests.test_golden_output.test_relative_error_values_match_golden[5]", + "eval.tests.test_golden_output.test_time_only_stdout_matches_golden[3]", + "eval.tests.test_golden_output.test_time_only_stdout_matches_golden[5]", + "eval.tests.test_golden_output.test_time_only_stdout_matches_golden[8]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[10]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[16]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[1]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[2]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[32]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[3]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[4]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[5]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[64]", + "eval.tests.test_normal_run.test_full_run_emits_exactly_n_relative_errors_per_group[8]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[10]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[16]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[1]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[2]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[32]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[3]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[4]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[5]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[64]", + "eval.tests.test_normal_run.test_full_run_reports_three_scalar_groups[8]", + "eval.tests.test_normal_run.test_relative_error_values_are_finite_and_nonnegative[16]", + "eval.tests.test_normal_run.test_relative_error_values_are_finite_and_nonnegative[2]", + "eval.tests.test_normal_run.test_relative_error_values_are_finite_and_nonnegative[3]", + "eval.tests.test_normal_run.test_relative_error_values_are_finite_and_nonnegative[5]", + "eval.tests.test_normal_run.test_relative_error_values_are_finite_and_nonnegative[8]", + "eval.tests.test_normal_run.test_runtime_and_error_count_are_consistent_across_groups[1]", + "eval.tests.test_normal_run.test_runtime_and_error_count_are_consistent_across_groups[3]", + "eval.tests.test_normal_run.test_runtime_and_error_count_are_consistent_across_groups[8]", + "eval.tests.test_normal_run.test_runtime_line_reports_positive_seconds", + "eval.tests.test_normal_run.test_runtime_lines_are_three_per_run_even_for_large_n[16]", + "eval.tests.test_normal_run.test_runtime_lines_are_three_per_run_even_for_large_n[4]", + "eval.tests.test_normal_run.test_runtime_token_format_adapts_to_magnitude[100000]", + "eval.tests.test_normal_run.test_runtime_token_format_adapts_to_magnitude[5]", + "eval.tests.test_normal_run.test_stress_n_100k_emits_all_elements", + "eval.tests.test_normal_run.test_stress_n_reports_all_elements_and_exits_zero[1000]", + "eval.tests.test_normal_run.test_stress_n_reports_all_elements_and_exits_zero[256]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[128]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[16]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[1]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[2]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[32]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[3]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[4]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[64]", + "eval.tests.test_normal_run.test_three_groups_emit_identical_relative_errors[8]", + "eval.tests.test_report_byte_structure.test_cross_mode_runtime_lines_identical_after_seconds_masked[3]", + "eval.tests.test_report_byte_structure.test_cross_mode_runtime_lines_identical_after_seconds_masked[5]", + "eval.tests.test_report_byte_structure.test_cross_mode_runtime_lines_identical_after_seconds_masked[8]", + "eval.tests.test_report_byte_structure.test_nonblank_lines_are_exactly_known_shapes_with_zero_unknown[4]", + "eval.tests.test_report_byte_structure.test_nonblank_lines_are_exactly_known_shapes_with_zero_unknown[5]", + "eval.tests.test_report_byte_structure.test_nonblank_lines_are_exactly_known_shapes_with_zero_unknown[7]", + "eval.tests.test_report_byte_structure.test_runtime_and_error_headers_share_identical_text_prefix[4]", + "eval.tests.test_report_byte_structure.test_runtime_and_error_headers_share_identical_text_prefix[6]", + "eval.tests.test_report_byte_structure.test_value_lines_start_with_exact_comma_space_and_have_no_trailing_ws[3]", + "eval.tests.test_report_byte_structure.test_value_lines_start_with_exact_comma_space_and_have_no_trailing_ws[6]", + "eval.tests.test_report_byte_structure.test_value_lines_start_with_exact_comma_space_and_have_no_trailing_ws[9]", + "eval.tests.test_stream_structure.test_mode_zero_line_count_obeys_formula_and_mode_one_is_three[10]", + "eval.tests.test_stream_structure.test_mode_zero_line_count_obeys_formula_and_mode_one_is_three[6]", + "eval.tests.test_stream_structure.test_mode_zero_line_count_obeys_formula_and_mode_one_is_three[7]", + "eval.tests.test_stream_structure.test_relative_errors_are_strict_ratios_in_open_unit_interval[3]", + "eval.tests.test_stream_structure.test_relative_errors_are_strict_ratios_in_open_unit_interval[5]", + "eval.tests.test_stream_structure.test_relative_errors_are_strict_ratios_in_open_unit_interval[8]", + "eval.tests.test_stream_structure.test_runtime_header_exact_text_prefix_for_each_group[3]", + "eval.tests.test_stream_structure.test_runtime_header_exact_text_prefix_for_each_group[5]", + "eval.tests.test_stream_structure.test_runtime_header_exact_text_prefix_for_each_group[8]", + "eval.tests.test_stream_structure.test_runtime_headers_share_identical_prefix_across_groups[16]", + "eval.tests.test_stream_structure.test_runtime_headers_share_identical_prefix_across_groups[1]", + "eval.tests.test_stream_structure.test_runtime_headers_share_identical_prefix_across_groups[4]", + "eval.tests.test_stream_structure.test_time_only_output_ends_with_single_newline_no_blank_separator[2]", + "eval.tests.test_stream_structure.test_time_only_output_ends_with_single_newline_no_blank_separator[4]", + "eval.tests.test_stream_structure.test_time_only_output_ends_with_single_newline_no_blank_separator[8]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[16]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[1]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[256]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[2]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[32]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[3]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[4]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[64]", + "eval.tests.test_stream_structure.test_time_only_output_is_exactly_three_lines_no_blanks[8]", + "eval.tests.test_time_only.test_atoi_truthiness_of_time_only_flag[-False]", + "eval.tests.test_time_only.test_atoi_truthiness_of_time_only_flag[0-False]", + "eval.tests.test_time_only.test_atoi_truthiness_of_time_only_flag[00-False]", + "eval.tests.test_time_only.test_atoi_truthiness_of_time_only_flag[0001-True]", + "eval.tests.test_time_only.test_atoi_truthiness_of_time_only_flag[01-True]", + "eval.tests.test_time_only.test_nonzero_time_only_suppresses_relative_errors[-1]", + "eval.tests.test_time_only.test_nonzero_time_only_suppresses_relative_errors[1]", + "eval.tests.test_time_only.test_nonzero_time_only_suppresses_relative_errors[2]", + "eval.tests.test_time_only.test_nonzero_time_only_suppresses_relative_errors[3]", + "eval.tests.test_time_only.test_nonzero_time_only_suppresses_relative_errors[7]", + "eval.tests.test_time_only.test_time_only_flag_numeric_prefix_truthiness[0.7-False]", + "eval.tests.test_time_only.test_time_only_flag_numeric_prefix_truthiness[0x1-False]", + "eval.tests.test_time_only.test_time_only_flag_numeric_prefix_truthiness[1e0-True]", + "eval.tests.test_time_only.test_time_only_flag_numeric_prefix_truthiness[2.5-True]", + "eval.tests.test_time_only.test_time_only_flag_numeric_prefix_truthiness[5e2-True]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[+0-False]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[+1-True]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[+12-True]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[-0-False]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[-1-True]", + "eval.tests.test_time_only.test_time_only_flag_signed_numeric_truthiness[-7-True]", + "eval.tests.test_time_only.test_time_only_flag_whitespace_preserved[ 0-False]", + "eval.tests.test_time_only.test_time_only_flag_whitespace_preserved[ 1-True]", + "eval.tests.test_time_only.test_time_only_flag_whitespace_preserved[ \\t0-False]", + "eval.tests.test_time_only.test_time_only_flag_whitespace_preserved[\\t2-True]", + "eval.tests.test_time_only.test_time_only_nonzero_with_zero_n_still_clean", + "eval.tests.test_time_only.test_time_only_still_reports_all_three_scalar_groups[-5]", + "eval.tests.test_time_only.test_time_only_still_reports_all_three_scalar_groups[1]", + "eval.tests.test_time_only.test_time_only_still_reports_all_three_scalar_groups[2]", + "eval.tests.test_time_only.test_time_only_truthy_vs_zero_share_n_runtime_lines", + "eval.tests.test_time_only.test_time_only_zero_prints_errors_but_toggle_differs_run_to_run[0]", + "eval.tests.test_time_only.test_time_only_zero_prints_errors_but_toggle_differs_run_to_run[16]", + "eval.tests.test_time_only.test_time_only_zero_prints_errors_but_toggle_differs_run_to_run[1]", + "eval.tests.test_time_only.test_time_only_zero_prints_errors_but_toggle_differs_run_to_run[4]" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_arguments.TestTimeOnlyArgument.test_timing_flag_one_suppresses_relative_error_values", + "reasons": [ + { + "id": "test_network_dependency", + "message": "test appears to depend on networking", + "path": "eval/tests/test_arguments.py", + "repair_hint": "Remove external networking from eval tests; use bundled fixtures or local subprocess behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_arguments.TestTimeOnlyArgument.test_verify_flag_reproduces_known_error_stream", + "reasons": [ + { + "id": "test_network_dependency", + "message": "test appears to depend on networking", + "path": "eval/tests/test_arguments.py", + "repair_hint": "Remove external networking from eval tests; use bundled fixtures or local subprocess behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_arguments.TestNArgument.test_atoi_prefix_parsing_matches_golden[ 003-3]", + "eval.tests.test_arguments.TestNArgument.test_atoi_prefix_parsing_matches_golden[+10-10]", + "eval.tests.test_arguments.TestNArgument.test_atoi_prefix_parsing_matches_golden[5abc-5]", + "eval.tests.test_arguments.TestNArgument.test_leading_and_trailing_whitespace_around_n[ 8]", + "eval.tests.test_arguments.TestNArgument.test_leading_and_trailing_whitespace_around_n[8 ]", + "eval.tests.test_arguments.TestNArgument.test_leading_and_trailing_whitespace_around_n[\\t8]", + "eval.tests.test_arguments.TestNArgument.test_leading_plus_n_is_accepted", + "eval.tests.test_arguments.TestNArgument.test_leading_zeros_n_is_accepted", + "eval.tests.test_arguments.TestNArgument.test_negative_n_crashes[-1]", + "eval.tests.test_arguments.TestNArgument.test_negative_n_crashes[-4]", + "eval.tests.test_arguments.TestNArgument.test_non_numeric_n_collapses_to_zero[ ]", + "eval.tests.test_arguments.TestNArgument.test_non_numeric_n_collapses_to_zero[abc]", + "eval.tests.test_arguments.TestNArgument.test_non_numeric_n_collapses_to_zero[xyz]", + "eval.tests.test_arguments.TestNArgument.test_numeric_prefix_n_parses_partial", + "eval.tests.test_arguments.TestNArgument.test_sign_only_and_hexlike_n_collapse_to_zero[+0]", + "eval.tests.test_arguments.TestNArgument.test_sign_only_and_hexlike_n_collapse_to_zero[+]", + "eval.tests.test_arguments.TestNArgument.test_sign_only_and_hexlike_n_collapse_to_zero[-0]", + "eval.tests.test_arguments.TestNArgument.test_sign_only_and_hexlike_n_collapse_to_zero[-]", + "eval.tests.test_arguments.TestNArgument.test_sign_only_and_hexlike_n_collapse_to_zero[0x8]", + "eval.tests.test_arguments.TestNArgument.test_sign_without_immediate_digit_parses_zero[+ 8]", + "eval.tests.test_arguments.TestNArgument.test_sign_without_immediate_digit_parses_zero[+ 8xyz]", + "eval.tests.test_arguments.TestNArgument.test_whitespace_sign_leadingzero_parse_to_nonzero[ +8 -8]", + "eval.tests.test_arguments.TestNArgument.test_whitespace_sign_leadingzero_parse_to_nonzero[08-8]", + "eval.tests.test_arguments.TestNArgument.test_whitespace_sign_leadingzero_parse_to_nonzero[42\\t-42]", + "eval.tests.test_arguments.TestNArgument.test_zero_length_n_runs_successfully", + "eval.tests.test_arguments.TestNArgument.test_zero_magnitude_with_trailing_noop_parses_zero[ +0trail]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_any_nonzero_time_only_suppresses_errors[-1]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_any_nonzero_time_only_suppresses_errors[1000]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_any_nonzero_time_only_suppresses_errors[2]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_any_nonzero_time_only_suppresses_errors[7]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_non_numeric_time_only_treated_as_zero[]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_non_numeric_time_only_treated_as_zero[abc]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_non_numeric_time_only_treated_as_zero[x]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_nonzero_time_only_parses_as_true[ 1]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_nonzero_time_only_parses_as_true[+3]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_nonzero_time_only_parses_as_true[01]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_nonzero_time_only_parses_as_true[1x]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_nonzero_time_only_parses_as_true[2.5]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_time_only_with_various_n[0]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_time_only_with_various_n[1]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_time_only_with_various_n[3]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_time_only_with_various_n[8]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_timing_flag_one_suppresses_relative_error_values", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_verify_flag_reproduces_known_error_stream", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_zero_time_only_asks_for_verification[neg-zero]", + "eval.tests.test_arguments.TestTimeOnlyArgument.test_zero_time_only_asks_for_verification[zero]", + "eval.tests.test_arguments.TestUsageAndArity.test_no_arguments_prints_usage_and_exits_1", + "eval.tests.test_arguments.TestUsageAndArity.test_single_argument_crashes_for_any_n[128]", + "eval.tests.test_arguments.TestUsageAndArity.test_single_argument_crashes_for_any_n[16]", + "eval.tests.test_arguments.TestUsageAndArity.test_single_argument_crashes_for_any_n[1]", + "eval.tests.test_arguments.TestUsageAndArity.test_single_argument_crashes_for_any_n[8]", + "eval.tests.test_arguments.TestUsageAndArity.test_single_argument_terminates_with_segfault", + "eval.tests.test_arguments.TestUsageAndArity.test_usage_banner_names_both_positional_parameters", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_distinct_elements_yield_distinct_errors", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[12]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[1]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[2]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[3]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[4]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_each_block_reproduces_golden_exactly[8]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_error_sequence_length_equals_vector_length", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_larger_dtype_family_is_no_less_precise", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_are_nonnegative_finite[1]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_are_nonnegative_finite[2]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_are_nonnegative_finite[4]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_are_nonnegative_finite[8]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_below_one[3]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_below_one[5]", + "eval.tests.test_dense_vector_semantics.TestAddSemantics.test_relative_errors_below_one[7]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_large_vectors_succeed[10000]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_large_vectors_succeed[1000]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_large_vectors_succeed[100]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[10]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[11]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[12]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[16]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[1]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[2]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[32]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[3]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[4]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[5]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[6]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[7]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[8]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_scaling_error_section_matches_golden[9]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_small_vectors_valid_in_verify_mode[16]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_small_vectors_valid_in_verify_mode[1]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_small_vectors_valid_in_verify_mode[4]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_small_vectors_valid_in_verify_mode[64]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_very_large_vectors_succeed[1000000]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_very_large_vectors_succeed[100000]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_zero_and_small_vectors_valid_in_timing_mode[0]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_zero_and_small_vectors_valid_in_timing_mode[16]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_zero_and_small_vectors_valid_in_timing_mode[1]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_zero_and_small_vectors_valid_in_timing_mode[4]", + "eval.tests.test_dense_vector_semantics.TestBoundarySizes.test_zero_length_verify_mode_has_empty_error_sections", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_full_stdout_equal_ignoring_timing[4]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_full_stdout_equal_ignoring_timing[6]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_full_stdout_equal_ignoring_timing[9]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_rerun_produces_identical_errors[10]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_rerun_produces_identical_errors[16]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_rerun_produces_identical_errors[3]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_rerun_produces_identical_errors[5]", + "eval.tests.test_dense_vector_semantics.TestCrossRunDeterminism.test_rerun_produces_identical_errors[8]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_extended_golden_reproduced_exactly[200]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_extended_golden_reproduced_exactly[20]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_extended_golden_reproduced_exactly[256]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_extended_golden_reproduced_exactly[40]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_extended_golden_reproduced_exactly[72]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_rerun_identical_for_larger_n[128]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_rerun_identical_for_larger_n[33]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_rerun_identical_for_larger_n[96]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_three_families_are_byte_identical[128]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_three_families_are_byte_identical[18]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_three_families_are_byte_identical[22]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_three_families_are_byte_identical[30]", + "eval.tests.test_dense_vector_semantics.TestExtendedDeterminism.test_three_families_are_byte_identical[50]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra0-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra0-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra0-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra1-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra1-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra1-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra2-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra2-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra2-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra3-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra3-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra3-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra4-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra4-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra4-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra5-2]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra5-5]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_change_error_stream[extra5-8]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_do_not_turn_timing_mode_into_verify_mode", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra0-16]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra0-1]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra0-4]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra1-16]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra1-1]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra1-4]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra2-16]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra2-1]", + "eval.tests.test_extra_args_and_scale.TestExtraArgumentsIgnored.test_extra_args_preserve_timing_only_structure[extra2-4]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_each_block_echoes_requested_length[10000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_each_block_echoes_requested_length[1000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_error_values_are_bounded_finite[100000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_error_values_are_bounded_finite[10000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_error_values_are_bounded_finite[1000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_verify_has_exact_structure[100000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_verify_has_exact_structure[10000]", + "eval.tests.test_extra_args_and_scale.TestVerifyModeAtScale.test_large_n_verify_has_exact_structure[1000]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_blank_n_verify_three_empty_sections[ ]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_blank_n_verify_three_empty_sections[\\t]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_blank_n_verify_three_empty_sections[]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[+0]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[+]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[-0]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[-]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[0x8]", + "eval.tests.test_extra_args_and_scale.TestZeroMagnitudeNInVerify.test_zero_n_form_verify_has_empty_error_sections[]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_goldens_are_rerun_stable[1024]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_goldens_are_rerun_stable[2048]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_goldens_are_rerun_stable[300]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_goldens_are_rerun_stable[512]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_live_stream_matches_golden_in_every_block[1024]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_live_stream_matches_golden_in_every_block[2048]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_live_stream_matches_golden_in_every_block[300]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_live_stream_matches_golden_in_every_block[512]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_verify_keeps_exact_line_budget[1024]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_verify_keeps_exact_line_budget[2048]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_verify_keeps_exact_line_budget[300]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_boundary_verify_keeps_exact_line_budget[512]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_golden_file_has_exactly_n_value_lines[1024]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_golden_file_has_exactly_n_value_lines[2048]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_golden_file_has_exactly_n_value_lines[300]", + "eval.tests.test_golden_errors.TestBoundaryGoldenExpansion.test_golden_file_has_exactly_n_value_lines[512]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[100]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[1024]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[10]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[11]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[128]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[12]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[13]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[14]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[15]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[160]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[16]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[17]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[18]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[19]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[1]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[200]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[2048]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[20]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[21]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[22]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[23]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[24]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[256]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[25]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[26]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[27]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[28]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[29]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[2]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[300]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[30]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[31]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[32]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[33]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[34]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[35]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[36]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[38]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[3]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[40]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[42]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[44]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[46]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[48]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[4]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[50]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[512]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[52]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[5]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[60]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[64]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[6]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[72]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[7]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[80]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[8]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[90]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[96]", + "eval.tests.test_golden_errors.test_all_block_sequences_match_golden[9]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[100]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[1024]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[10]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[11]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[128]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[12]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[13]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[14]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[15]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[160]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[16]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[17]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[18]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[19]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[1]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[200]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[2048]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[20]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[21]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[22]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[23]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[24]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[256]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[25]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[26]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[27]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[28]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[29]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[2]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[300]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[30]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[31]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[32]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[33]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[34]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[35]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[36]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[38]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[3]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[40]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[42]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[44]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[46]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[48]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[4]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[50]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[512]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[52]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[5]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[60]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[64]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[6]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[72]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[7]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[80]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[8]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[90]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[96]", + "eval.tests.test_golden_errors.test_first_block_errors_match_golden[9]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[100]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[1024]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[10]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[11]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[128]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[12]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[13]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[14]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[15]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[160]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[16]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[17]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[18]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[19]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[1]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[200]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[2048]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[20]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[21]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[22]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[23]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[24]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[256]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[25]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[26]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[27]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[28]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[29]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[2]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[300]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[30]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[31]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[32]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[33]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[34]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[35]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[36]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[38]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[3]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[40]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[42]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[44]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[46]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[48]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[4]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[50]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[512]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[52]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[5]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[60]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[64]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[6]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[72]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[7]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[80]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[8]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[90]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[96]", + "eval.tests.test_golden_errors.test_golden_files_are_read_only_resources[9]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[100]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[1024]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[10]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[11]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[128]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[12]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[13]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[14]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[15]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[160]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[16]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[17]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[18]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[19]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[1]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[200]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[2048]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[20]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[21]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[22]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[23]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[24]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[256]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[25]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[26]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[27]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[28]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[29]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[2]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[300]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[30]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[31]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[32]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[33]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[34]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[35]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[36]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[38]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[3]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[40]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[42]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[44]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[46]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[48]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[4]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[50]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[512]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[52]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[5]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[60]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[64]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[6]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[72]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[7]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[80]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[8]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[90]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[96]", + "eval.tests.test_golden_errors.test_live_error_values_are_bounded_and_match_golden[9]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[100]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[1024]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[10]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[11]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[128]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[12]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[13]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[14]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[15]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[160]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[16]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[17]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[18]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[19]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[1]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[200]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[2048]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[20]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[21]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[22]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[23]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[24]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[256]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[25]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[26]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[27]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[28]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[29]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[2]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[300]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[30]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[31]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[32]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[33]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[34]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[35]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[36]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[38]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[3]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[40]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[42]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[44]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[46]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[48]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[4]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[50]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[512]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[52]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[5]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[60]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[64]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[6]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[72]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[7]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[80]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[8]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[90]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[96]", + "eval.tests.test_golden_errors.test_run_and_regen_are_byte_identical[9]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_huge_positive_and_negative_flags_are_timing_mode[-2147483648]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_huge_positive_and_negative_flags_are_timing_mode[-999999999999]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_huge_positive_and_negative_flags_are_timing_mode[2147483647]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_huge_positive_and_negative_flags_are_timing_mode[2147483648]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_near_int32_extremes_still_timing[-2147483647]", + "eval.tests.test_large_and_count_oracles.TestAtoiSaturationFlags.test_near_int32_extremes_still_timing[2147483646]", + "eval.tests.test_large_and_count_oracles.TestBannerPositions.test_blank_n_verify_has_three_headers_and_zero_values", + "eval.tests.test_large_and_count_oracles.TestBannerPositions.test_runtime_banner_is_first_line_of_each_block[2]", + "eval.tests.test_large_and_count_oracles.TestBannerPositions.test_runtime_banner_is_first_line_of_each_block[5]", + "eval.tests.test_large_and_count_oracles.TestBannerPositions.test_runtime_banner_is_first_line_of_each_block[8]", + "eval.tests.test_large_and_count_oracles.TestLargeNModeDeterminism.test_large_n_echoes_length_in_every_banner[1000000]", + "eval.tests.test_large_and_count_oracles.TestLargeNModeDeterminism.test_large_n_echoes_length_in_every_banner[500000]", + "eval.tests.test_large_and_count_oracles.TestLargeNModeDeterminism.test_large_n_timing_rerun_identical_after_strip[1000000]", + "eval.tests.test_large_and_count_oracles.TestLargeNModeDeterminism.test_large_n_timing_rerun_identical_after_strip[500000]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_every_value_line_has_exactly_one_comma_prefix[16]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_every_value_line_has_exactly_one_comma_prefix[5]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_timing_mode_has_three_runtime_tokens_and_no_headers[12]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_timing_mode_has_three_runtime_tokens_and_no_headers[300]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_timing_mode_has_three_runtime_tokens_and_no_headers[4]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_verify_mode_has_three_each_of_token_kind[12]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_verify_mode_has_three_each_of_token_kind[300]", + "eval.tests.test_large_and_count_oracles.TestWholeStreamTokenCounts.test_verify_mode_has_three_each_of_token_kind[4]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[0-1]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[1-0]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[100-1]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[16-0]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[300-0]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[4096-1]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_exactly_three_runtime_banners_with_f_token[7-1]", + "eval.tests.test_mode_and_family_consistency.TestFamilyTokenUniformity.test_family_token_is_f_in_verify_mode_too", + "eval.tests.test_mode_and_family_consistency.TestInputDiscrimination.test_distinct_lengths_yield_distinct_streams[11-12]", + "eval.tests.test_mode_and_family_consistency.TestInputDiscrimination.test_distinct_lengths_yield_distinct_streams[3-4]", + "eval.tests.test_mode_and_family_consistency.TestInputDiscrimination.test_distinct_lengths_yield_distinct_streams[7-8]", + "eval.tests.test_mode_and_family_consistency.TestLengthEchoConsistency.test_banner_lengths_agree_with_golden_length[12]", + "eval.tests.test_mode_and_family_consistency.TestLengthEchoConsistency.test_banner_lengths_agree_with_golden_length[1]", + "eval.tests.test_mode_and_family_consistency.TestLengthEchoConsistency.test_banner_lengths_agree_with_golden_length[3]", + "eval.tests.test_mode_and_family_consistency.TestLengthEchoConsistency.test_banner_lengths_agree_with_golden_length[8]", + "eval.tests.test_mode_and_family_consistency.TestStdinIsIgnored.test_stdin_bytes_do_not_change_stdout[12-0-some tracker lines\\nto ignore\\n]", + "eval.tests.test_mode_and_family_consistency.TestStdinIsIgnored.test_stdin_bytes_do_not_change_stdout[4-0-n: 1, f Runtime(s): 0\\n]", + "eval.tests.test_mode_and_family_consistency.TestStdinIsIgnored.test_stdin_bytes_do_not_change_stdout[4-1-hello\\nworld\\n]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[12]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[1]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[2]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[3]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[5]", + "eval.tests.test_output_structure.TestBlockLayout.test_each_banner_echoes_n_exactly[8]", + "eval.tests.test_output_structure.TestBlockLayout.test_emits_three_runtime_banners[16]", + "eval.tests.test_output_structure.TestBlockLayout.test_emits_three_runtime_banners[1]", + "eval.tests.test_output_structure.TestBlockLayout.test_emits_three_runtime_banners[2]", + "eval.tests.test_output_structure.TestBlockLayout.test_emits_three_runtime_banners[4]", + "eval.tests.test_output_structure.TestBlockLayout.test_emits_three_runtime_banners[7]", + "eval.tests.test_output_structure.TestBlockLayout.test_runtime_line_full_format", + "eval.tests.test_output_structure.TestBlockLayout.test_runtime_seconds_is_a_nonnegative_float", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[10]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[2]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[3]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[4]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[5]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[6]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[7]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_all_three_blocks_are_identical[8]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_header_uses_exact_relative_errors_phrase", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[10]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[12]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[1]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[2]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[3]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[4]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[5]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[6]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_section_matches_golden[8]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_values_are_bounded_decimal_floats[1]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_values_are_bounded_decimal_floats[3]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_values_are_bounded_decimal_floats[6]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_error_values_are_bounded_decimal_floats[9]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[1]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[2]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[3]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[4]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[5]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[6]", + "eval.tests.test_output_structure.TestErrorSectionLayout.test_three_error_sections_each_with_n_values[8]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_timing_mode_has_no_trailing_blank_lines[1]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_timing_mode_has_no_trailing_blank_lines[4]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_timing_mode_has_no_trailing_blank_lines[9]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verification_mode_trailing_blank_lines_per_block[1]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verification_mode_trailing_blank_lines_per_block[4]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verification_mode_trailing_blank_lines_per_block[9]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[12]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[24]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[2]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[3]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[5]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_has_relative_errors_header_three_times[8]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_total_line_count_is_three_per_block[0]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_total_line_count_is_three_per_block[16]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_total_line_count_is_three_per_block[1]", + "eval.tests.test_output_structure.TestSectionDelimiters.test_verify_mode_total_line_count_is_three_per_block[4]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_success_with_extra_args_keeps_stderr_empty[12-0-extra2]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_success_with_extra_args_keeps_stderr_empty[4-0-extra0]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_success_with_extra_args_keeps_stderr_empty[8-1-extra1]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[0-1]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[1-0]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[100-1]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[1000-0]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[16-0]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[256-0]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[4096-1]", + "eval.tests.test_stream_hygiene.TestStderrHygiene.test_successful_runs_have_empty_stderr[7-1]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_mode_rerun_is_byte_identical[16]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_mode_rerun_is_byte_identical[1]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_mode_rerun_is_byte_identical[4]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_mode_rerun_is_byte_identical[64]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_tokens_parse_as_positive_floats[2]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_tokens_parse_as_positive_floats[32]", + "eval.tests.test_stream_hygiene.TestTimingModeDeterminism.test_timing_tokens_parse_as_positive_floats[8]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_abnormal_args.test_empty_string_n_is_zero", + "eval.tests.test_abnormal_args.test_extra_trailing_args_ignored[extra0]", + "eval.tests.test_abnormal_args.test_extra_trailing_args_ignored[extra1]", + "eval.tests.test_abnormal_args.test_extra_trailing_args_ignored[extra2]", + "eval.tests.test_abnormal_args.test_leading_plus_sign_accepted", + "eval.tests.test_abnormal_args.test_missing_time_only_arg_is_sigsegv[100]", + "eval.tests.test_abnormal_args.test_missing_time_only_arg_is_sigsegv[1]", + "eval.tests.test_abnormal_args.test_missing_time_only_arg_is_sigsegv[8]", + "eval.tests.test_abnormal_args.test_negative_n_aborts_with_sigsegv", + "eval.tests.test_abnormal_args.test_negative_n_never_prints_error_headers", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[--help]", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[-x]", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[abc]", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[foo]", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[hello]", + "eval.tests.test_abnormal_args.test_non_numeric_n_coerces_to_zero_full_output[xyz]", + "eval.tests.test_abnormal_args.test_non_numeric_n_with_time_only", + "eval.tests.test_abnormal_args.test_partial_numeric_prefix_scales_output", + "eval.tests.test_abnormal_args.test_plus_zero_n_with_trailing_garbage", + "eval.tests.test_additional_surface.test_fractional_negative_t_below_one_is_full_mode", + "eval.tests.test_additional_surface.test_full_mode_additional_n_block_count[10]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_block_count[16]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_block_count[20]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_block_count[9]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_matches_golden[10]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_matches_golden[16]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_matches_golden[20]", + "eval.tests.test_additional_surface.test_full_mode_additional_n_matches_golden[9]", + "eval.tests.test_additional_surface.test_large_n_timing_mode_is_bounded", + "eval.tests.test_additional_surface.test_large_n_timing_mode_is_faster_than_full_mode", + "eval.tests.test_additional_surface.test_leading_space_negative_n_crashes", + "eval.tests.test_additional_surface.test_leading_space_negative_n_no_output", + "eval.tests.test_additional_surface.test_medium_n_full_mode_exact_golden", + "eval.tests.test_additional_surface.test_same_n_cross_mode_error_header_contrast", + "eval.tests.test_additional_surface.test_sign_only_n_coerces_to_zero[+]", + "eval.tests.test_additional_surface.test_sign_only_n_coerces_to_zero[-]", + "eval.tests.test_additional_surface.test_surrounding_whitespace_n_coerces_to_seven", + "eval.tests.test_additional_surface.test_t_with_nonzero_atoi_truncation_is_timing[-1abc]", + "eval.tests.test_additional_surface.test_t_with_nonzero_atoi_truncation_is_timing[007]", + "eval.tests.test_additional_surface.test_t_with_nonzero_atoi_truncation_is_timing[2.9]", + "eval.tests.test_additional_surface.test_time_only_additional_n_matches_golden[12]", + "eval.tests.test_additional_surface.test_time_only_additional_n_matches_golden[16]", + "eval.tests.test_additional_surface.test_time_only_additional_n_matches_golden[3]", + "eval.tests.test_additional_surface.test_time_only_additional_n_matches_golden[6]", + "eval.tests.test_additional_surface.test_time_only_additional_n_matches_golden[9]", + "eval.tests.test_additional_surface.test_time_only_additional_n_three_lines[12]", + "eval.tests.test_additional_surface.test_time_only_additional_n_three_lines[16]", + "eval.tests.test_additional_surface.test_time_only_additional_n_three_lines[3]", + "eval.tests.test_additional_surface.test_time_only_additional_n_three_lines[6]", + "eval.tests.test_additional_surface.test_time_only_additional_n_three_lines[9]", + "eval.tests.test_additional_surface.test_time_only_distinct_n_produce_distinct_outputs", + "eval.tests.test_argc_edge_cases.test_argc2_crash_is_not_n_dependent", + "eval.tests.test_argc_edge_cases.test_argc2_non_numeric_n_still_segfaults[+]", + "eval.tests.test_argc_edge_cases.test_argc2_non_numeric_n_still_segfaults[-]", + "eval.tests.test_argc_edge_cases.test_argc2_non_numeric_n_still_segfaults[]", + "eval.tests.test_argc_edge_cases.test_argc2_non_numeric_n_still_segfaults[abc]", + "eval.tests.test_argc_edge_cases.test_argc2_non_numeric_n_still_segfaults[xyz]", + "eval.tests.test_argc_edge_cases.test_argc2_numeric_n_segfaults[ 12]", + "eval.tests.test_argc_edge_cases.test_argc2_numeric_n_segfaults[08]", + "eval.tests.test_argc_edge_cases.test_argc2_numeric_n_segfaults[7]", + "eval.tests.test_argc_edge_cases.test_argc2_zero_and_whitespace_n_still_segfaults[ ]", + "eval.tests.test_argc_edge_cases.test_argc2_zero_and_whitespace_n_still_segfaults[0]", + "eval.tests.test_argc_edge_cases.test_argc2_zero_and_whitespace_n_still_segfaults[\\t]", + "eval.tests.test_argc_edge_cases.test_same_n_survives_when_negative_t_present", + "eval.tests.test_argc_edge_cases.test_same_n_survives_when_t_present", + "eval.tests.test_atoi_coercion.test_distinct_n_values_produce_distinct_outputs", + "eval.tests.test_atoi_coercion.test_float_t_below_one_selects_full_mode", + "eval.tests.test_atoi_coercion.test_mixed_sign_plus_suffix", + "eval.tests.test_atoi_coercion.test_n_whitespace_and_zero_prefix_parse[ 7]", + "eval.tests.test_atoi_coercion.test_n_whitespace_and_zero_prefix_parse[+7]", + "eval.tests.test_atoi_coercion.test_n_whitespace_and_zero_prefix_parse[007]", + "eval.tests.test_atoi_coercion.test_n_whitespace_and_zero_prefix_parse[7 ]", + "eval.tests.test_atoi_coercion.test_n_whitespace_and_zero_prefix_parse[\\t7]", + "eval.tests.test_atoi_coercion.test_negative_zero_t_selects_full_mode", + "eval.tests.test_atoi_coercion.test_nleading_zero_scales_output", + "eval.tests.test_atoi_coercion.test_t_with_positive_integer_part_selects_timing[+1]", + "eval.tests.test_atoi_coercion.test_t_with_positive_integer_part_selects_timing[1.5]", + "eval.tests.test_atoi_coercion.test_t_with_positive_integer_part_selects_timing[1abc]", + "eval.tests.test_atoi_coercion.test_t_with_positive_integer_part_selects_timing[1e3]", + "eval.tests.test_atoi_coercion.test_t_with_positive_integer_part_selects_timing[5.99]", + "eval.tests.test_atoi_coercion.test_whitespace_only_n_is_zero", + "eval.tests.test_boundary_n.test_large_n_full_mode_error_count", + "eval.tests.test_boundary_n.test_large_n_full_mode_matches_golden", + "eval.tests.test_boundary_n.test_minus_one_aborts_with_sigsegv", + "eval.tests.test_boundary_n.test_negative_n_aborts_with_sigsegv", + "eval.tests.test_boundary_n.test_negative_n_never_prints_success_output", + "eval.tests.test_boundary_n.test_negative_zero_is_not_a_crash", + "eval.tests.test_boundary_n.test_single_element_n_matches_golden", + "eval.tests.test_boundary_n.test_zero_n_full_mode_matches_golden", + "eval.tests.test_boundary_n.test_zero_n_has_three_empty_error_blocks", + "eval.tests.test_boundary_n.test_zero_n_time_only_matches_golden", + "eval.tests.test_boundary_n.test_zero_n_uses_atoi_zero_prefix_not_negative", + "eval.tests.test_cli_usage.test_no_args_emits_nothing_before_usage", + "eval.tests.test_cli_usage.test_no_args_exits_nonzero_and_prints_usage", + "eval.tests.test_cli_usage.test_no_args_prints_usage_to_stdout_not_stderr", + "eval.tests.test_cli_usage.test_usage_deterministic_across_invocations", + "eval.tests.test_cli_usage.test_usage_embeds_invoked_program_path", + "eval.tests.test_cli_usage.test_usage_is_a_single_line", + "eval.tests.test_error_values.test_error_values_are_finite_in_unit_range[1]", + "eval.tests.test_error_values.test_error_values_are_finite_in_unit_range[2]", + "eval.tests.test_error_values.test_error_values_are_finite_in_unit_range[4]", + "eval.tests.test_error_values.test_error_values_are_finite_in_unit_range[5]", + "eval.tests.test_error_values.test_error_values_are_finite_in_unit_range[8]", + "eval.tests.test_error_values.test_error_values_are_nonzero_for_positive_n", + "eval.tests.test_error_values.test_error_values_deterministic_across_runs[2]", + "eval.tests.test_error_values.test_error_values_deterministic_across_runs[4]", + "eval.tests.test_error_values.test_error_values_match_golden[1]", + "eval.tests.test_error_values.test_error_values_match_golden[2]", + "eval.tests.test_error_values.test_error_values_match_golden[4]", + "eval.tests.test_error_values.test_error_values_match_golden[5]", + "eval.tests.test_error_values.test_single_element_error", + "eval.tests.test_error_values.test_three_blocks_produce_identical_errors", + "eval.tests.test_n_fractional_truncation.test_float_n_timing_mode_bounded_runtime_token", + "eval.tests.test_n_fractional_truncation.test_fractional_n_full_mode_block_count_uses_truncated_value", + "eval.tests.test_n_fractional_truncation.test_fractional_n_is_truncation_not_rounding[3.7-3]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_is_truncation_not_rounding[5.9-5]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_timing_mode_truncates[1e3-1]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_timing_mode_truncates[5.9-5]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_truncates_to_integer_part[1e3-1]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_truncates_to_integer_part[3.7-3]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_truncates_to_integer_part[5.9-5]", + "eval.tests.test_n_fractional_truncation.test_fractional_n_truncates_to_integer_part[7.99-7]", + "eval.tests.test_n_fractional_truncation.test_scientific_n_does_not_exponentiate", + "eval.tests.test_n_fractional_truncation.test_truncated_n_agrees_with_covered_integer_golden", + "eval.tests.test_runtime_structure.test_full_mode_blank_separators_between_blocks", + "eval.tests.test_runtime_structure.test_full_mode_error_block_structure[1]", + "eval.tests.test_runtime_structure.test_full_mode_error_block_structure[4]", + "eval.tests.test_runtime_structure.test_full_mode_error_block_structure[7]", + "eval.tests.test_runtime_structure.test_full_mode_stdout_stderr_channels", + "eval.tests.test_runtime_structure.test_full_mode_structure_determinism[3]", + "eval.tests.test_runtime_structure.test_full_mode_structure_determinism[6]", + "eval.tests.test_runtime_structure.test_full_mode_three_runtime_lines_echo_n[1]", + "eval.tests.test_runtime_structure.test_full_mode_three_runtime_lines_echo_n[3]", + "eval.tests.test_runtime_structure.test_full_mode_three_runtime_lines_echo_n[5]", + "eval.tests.test_runtime_structure.test_full_mode_three_runtime_lines_echo_n[7]", + "eval.tests.test_runtime_structure.test_full_mode_timing_values_are_positive", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[1]", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[2]", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[3]", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[4]", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[5]", + "eval.tests.test_runtime_structure.test_full_mode_total_line_count_matches_golden[8]", + "eval.tests.test_runtime_structure.test_header_syntax_exact[2]", + "eval.tests.test_runtime_structure.test_header_syntax_exact[5]", + "eval.tests.test_runtime_structure.test_scalar_type_token_is_three_float_runtime_lines", + "eval.tests.test_time_only.test_any_nonzero_t_acts_as_time_only[-1]", + "eval.tests.test_time_only.test_any_nonzero_t_acts_as_time_only[-7]", + "eval.tests.test_time_only.test_any_nonzero_t_acts_as_time_only[2]", + "eval.tests.test_time_only.test_any_nonzero_t_acts_as_time_only[3]", + "eval.tests.test_time_only.test_any_nonzero_t_acts_as_time_only[99]", + "eval.tests.test_time_only.test_time_only_large_n_has_no_error_rows", + "eval.tests.test_time_only.test_time_only_large_n_matches_golden", + "eval.tests.test_time_only.test_time_only_mode_deterministic", + "eval.tests.test_time_only.test_time_only_prints_only_three_runtime_lines[1000]", + "eval.tests.test_time_only.test_time_only_prints_only_three_runtime_lines[1]", + "eval.tests.test_time_only.test_time_only_prints_only_three_runtime_lines[2]", + "eval.tests.test_time_only.test_time_only_prints_only_three_runtime_lines[8]", + "eval.tests.test_time_only.test_time_only_three_runtime_lines_echo_n[1000]", + "eval.tests.test_time_only.test_time_only_three_runtime_lines_echo_n[1]", + "eval.tests.test_time_only.test_time_only_three_runtime_lines_echo_n[4]", + "eval.tests.test_time_only.test_time_only_three_runtime_lines_echo_n[7]", + "eval.tests.test_time_only.test_time_only_zero_disabled", + "eval.tests.test_time_only.test_time_only_zero_n_three_lines" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[12]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[15]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[20]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[30]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[7]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[8]", + "eval.tests.test_additional_goldens_and_whitespace.test_all_three_blocks_agree_with_additional_golden[9]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[ 12-12]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[ 5-5]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[-0]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[5 -5]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[5 5-5]", + "eval.tests.test_additional_goldens_and_whitespace.test_atoi_whitespace_shapes_report_parsed_n[\\t3-3]", + "eval.tests.test_additional_goldens_and_whitespace.test_blank_first_arg_is_n_zero_not_a_crash", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[12]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[15]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[20]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[30]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[7]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[8]", + "eval.tests.test_additional_goldens_and_whitespace.test_error_lines_match_additional_golden[9]", + "eval.tests.test_arg_validation.test_extra_args_are_ignored", + "eval.tests.test_arg_validation.test_many_extra_args_are_ignored", + "eval.tests.test_arg_validation.test_no_args_prints_usage_and_exits_nonzero", + "eval.tests.test_arg_validation.test_no_args_stderr_is_empty", + "eval.tests.test_arg_validation.test_single_colon_arg_segfaults", + "eval.tests.test_arg_validation.test_single_integer_arg_segfaults", + "eval.tests.test_arg_validation.test_single_non_numeric_arg_segfaults", + "eval.tests.test_arg_validation.test_usage_banner_semantics", + "eval.tests.test_atoi_sign_and_base_edges.test_hex_style_arg_stops_at_x_reports_zero[0x10]", + "eval.tests.test_atoi_sign_and_base_edges.test_hex_style_arg_stops_at_x_reports_zero[0x]", + "eval.tests.test_atoi_sign_and_base_edges.test_hex_style_arg_stops_at_x_reports_zero[0xbeef]", + "eval.tests.test_atoi_sign_and_base_edges.test_hex_zero_still_shows_errors_when_requested", + "eval.tests.test_atoi_sign_and_base_edges.test_leading_zero_full_report_matches_plain_size", + "eval.tests.test_atoi_sign_and_base_edges.test_leading_zeroes_are_stripped[000-0]", + "eval.tests.test_atoi_sign_and_base_edges.test_leading_zeroes_are_stripped[0009-9]", + "eval.tests.test_atoi_sign_and_base_edges.test_leading_zeroes_are_stripped[007-7]", + "eval.tests.test_atoi_sign_and_base_edges.test_leading_zeroes_are_stripped[0128-128]", + "eval.tests.test_atoi_sign_and_base_edges.test_plus_sign_contrast_with_minus_sign", + "eval.tests.test_atoi_sign_and_base_edges.test_plus_sign_first_arg_parses_without_crash[+0-0]", + "eval.tests.test_atoi_sign_and_base_edges.test_plus_sign_first_arg_parses_without_crash[+1-1]", + "eval.tests.test_atoi_sign_and_base_edges.test_plus_sign_first_arg_parses_without_crash[+5-5]", + "eval.tests.test_atoi_sign_and_base_edges.test_plus_sign_first_arg_parses_without_crash[+9-9]", + "eval.tests.test_boundaries.test_large_n_runs_to_completion", + "eval.tests.test_boundaries.test_n_one_is_minimal_block", + "eval.tests.test_boundaries.test_n_zero_runs_with_three_timings", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[-1-False]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[0-True]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[0.9-True]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[00-True]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[1-False]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[2-False]", + "eval.tests.test_boundaries.test_time_only_flag_is_atoi_bool[7x-False]", + "eval.tests.test_boundaries.test_very_large_n_runs_to_completion", + "eval.tests.test_determinism.test_error_output_is_deterministic_across_runs", + "eval.tests.test_determinism.test_multiple_sizes_deterministic", + "eval.tests.test_determinism.test_runtime_lines_are_varies_but_structure_stable", + "eval.tests.test_full_document_golden.test_blank_separator_after_each_block_is_double_newline", + "eval.tests.test_full_document_golden.test_full_report_matches_document_golden[3-full_N3.txt]", + "eval.tests.test_full_document_golden.test_timing_values_are_the_only_varying_text", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-100]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-10]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-1]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-2]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-3]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-4]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-5]", + "eval.tests.test_golden.test_error_values_match_golden[bhalf-6]", + "eval.tests.test_golden.test_error_values_match_golden[float-100]", + "eval.tests.test_golden.test_error_values_match_golden[float-10]", + "eval.tests.test_golden.test_error_values_match_golden[float-1]", + "eval.tests.test_golden.test_error_values_match_golden[float-2]", + "eval.tests.test_golden.test_error_values_match_golden[float-3]", + "eval.tests.test_golden.test_error_values_match_golden[float-4]", + "eval.tests.test_golden.test_error_values_match_golden[float-5]", + "eval.tests.test_golden.test_error_values_match_golden[float-6]", + "eval.tests.test_golden.test_error_values_match_golden[half-100]", + "eval.tests.test_golden.test_error_values_match_golden[half-10]", + "eval.tests.test_golden.test_error_values_match_golden[half-1]", + "eval.tests.test_golden.test_error_values_match_golden[half-2]", + "eval.tests.test_golden.test_error_values_match_golden[half-3]", + "eval.tests.test_golden.test_error_values_match_golden[half-4]", + "eval.tests.test_golden.test_error_values_match_golden[half-5]", + "eval.tests.test_golden.test_error_values_match_golden[half-6]", + "eval.tests.test_golden.test_first_block_value_semantics", + "eval.tests.test_header_document_contract.test_each_block_scalar_token_is_f", + "eval.tests.test_header_document_contract.test_error_headers_carry_same_scalar_token", + "eval.tests.test_header_document_contract.test_first_output_line_is_first_timing_header", + "eval.tests.test_header_document_contract.test_full_report_has_six_n_headers[2]", + "eval.tests.test_header_document_contract.test_full_report_has_six_n_headers[3]", + "eval.tests.test_header_document_contract.test_full_report_has_six_n_headers[5]", + "eval.tests.test_header_document_contract.test_full_report_has_six_n_headers[8]", + "eval.tests.test_header_document_contract.test_full_report_headers_alternate_runtime_then_errors[2]", + "eval.tests.test_header_document_contract.test_full_report_headers_alternate_runtime_then_errors[3]", + "eval.tests.test_header_document_contract.test_full_report_headers_alternate_runtime_then_errors[6]", + "eval.tests.test_header_document_contract.test_time_only_report_has_three_n_headers[10]", + "eval.tests.test_header_document_contract.test_time_only_report_has_three_n_headers[1]", + "eval.tests.test_header_document_contract.test_time_only_report_has_three_n_headers[3]", + "eval.tests.test_header_document_contract.test_zero_length_full_report_still_has_six_headers", + "eval.tests.test_input_parsing.test_colon_form_m_size_is_m", + "eval.tests.test_input_parsing.test_colon_form_with_large_cargo", + "eval.tests.test_input_parsing.test_float_magnitude_first_arg_truncated", + "eval.tests.test_input_parsing.test_negative_first_arg_parses_then_aborts", + "eval.tests.test_input_parsing.test_non_numeric_first_arg_is_zero", + "eval.tests.test_input_parsing.test_partial_numeric_truncated_at_first_non_digit", + "eval.tests.test_input_parsing.test_reported_size_matches_parsed_integer_not_raw_arg", + "eval.tests.test_large_n_golden.test_all_three_blocks_match_large_n_golden[200]", + "eval.tests.test_large_n_golden.test_all_three_blocks_match_large_n_golden[25]", + "eval.tests.test_large_n_golden.test_all_three_blocks_match_large_n_golden[50]", + "eval.tests.test_large_n_golden.test_error_lines_match_large_n_golden[n200]", + "eval.tests.test_large_n_golden.test_error_lines_match_large_n_golden[n25]", + "eval.tests.test_large_n_golden.test_error_lines_match_large_n_golden[n50]", + "eval.tests.test_large_n_golden.test_large_n_golden_covers_mixed_digit_formats", + "eval.tests.test_negative_boundary_regimes.test_boundary_is_adjacent_at_minus31_minus32", + "eval.tests.test_negative_boundary_regimes.test_minus31_is_sigsegv_clean_streams", + "eval.tests.test_negative_boundary_regimes.test_minus32_abort_reports_sigabrt_not_partial_report", + "eval.tests.test_negative_boundary_regimes.test_minus32_crosses_to_sigabrt", + "eval.tests.test_negative_boundary_regimes.test_minus34_flips_to_huge_tib_diagnostic", + "eval.tests.test_negative_boundary_regimes.test_tib_diagnostic_is_stable_from_minus34_downward", + "eval.tests.test_negative_boundary_regimes.test_wrap_zero_diagnostic_is_stable_across_the_two_magnitudes", + "eval.tests.test_negative_boundary_regimes.test_wrap_zero_size_diagnostic_matches_golden[-32]", + "eval.tests.test_negative_boundary_regimes.test_wrap_zero_size_diagnostic_matches_golden[-33]", + "eval.tests.test_output_format.test_error_header_lines_are_byte_exact", + "eval.tests.test_output_format.test_error_line_digits_avoid_scientific_notation", + "eval.tests.test_output_format.test_every_error_line_is_canonical_float", + "eval.tests.test_output_format.test_every_timing_value_is_valid_float", + "eval.tests.test_output_format.test_no_line_is_truncated_or_blank_except_separators", + "eval.tests.test_output_format.test_timing_value_headers_are_exactly_prefixed", + "eval.tests.test_output_format.test_tiny_timing_uses_scientific_notation", + "eval.tests.test_output_structure.test_blocks_separated_by_blank_lines", + "eval.tests.test_output_structure.test_error_blocks_present_only_when_not_time_only", + "eval.tests.test_output_structure.test_error_header_immediately_after_runtime", + "eval.tests.test_output_structure.test_error_line_count_is_three_times_n", + "eval.tests.test_output_structure.test_error_values_are_positive_finite", + "eval.tests.test_output_structure.test_relative_errors_header_annotates_size", + "eval.tests.test_output_structure.test_successful_run_writes_nothing_to_stderr", + "eval.tests.test_output_structure.test_three_blocks_report_identical_error_values", + "eval.tests.test_output_structure.test_three_timing_blocks_always", + "eval.tests.test_output_structure.test_time_only_run_writes_nothing_to_stderr", + "eval.tests.test_output_structure.test_timing_header_annotates_size_and_name[10]", + "eval.tests.test_output_structure.test_timing_header_annotates_size_and_name[1]", + "eval.tests.test_output_structure.test_timing_header_annotates_size_and_name[25]", + "eval.tests.test_output_structure.test_timing_header_annotates_size_and_name[2]", + "eval.tests.test_output_structure.test_timing_header_annotates_size_and_name[5]", + "eval.tests.test_scaling_boundaries.test_error_counts_scale_linearly_for_multiples", + "eval.tests.test_scaling_boundaries.test_moderate_n_keeps_3x_contract", + "eval.tests.test_scaling_boundaries.test_power_of_two_n_full_report", + "eval.tests.test_scaling_boundaries.test_power_of_two_n_time_only", + "eval.tests.test_scaling_boundaries.test_prime_n_full_report", + "eval.tests.test_scaling_boundaries.test_size_one_thousand_full_report", + "eval.tests.test_second_arg_atoi_edges.test_first_arg_negative_zero_is_clean_n_zero", + "eval.tests.test_second_arg_atoi_edges.test_first_arg_negative_zero_time_only", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[ -True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[+1-False]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[-0-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[000-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[007-False]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_decides_error_blocks[0x10-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[ -True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[+1-False]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[-0-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[000-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[007-False]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_atoi_shape_leaves_six_or_three_n_headers[0x10-True]", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_empty_string_is_full_report", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_hex_zero_is_full_report", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_leading_zero_nonzero_is_time_only", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_leading_zero_zero_is_full_report", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_negative_zero_is_full_report", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_plus_one_is_time_only", + "eval.tests.test_second_arg_atoi_edges.test_second_arg_whitespace_only_is_full_report", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_bare_sign_at_larger_n[+]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_bare_sign_at_larger_n[-]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_bare_sign_at_larger_n[A]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_bare_sign_at_larger_n[abc]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_bare_sign_at_larger_n[x]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_contrast_nonzero_shapes[+1]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_contrast_nonzero_shapes[-1]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_contrast_nonzero_shapes[007]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_or_bare_sign_is_full_report[+]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_or_bare_sign_is_full_report[-]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_or_bare_sign_is_full_report[A]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_or_bare_sign_is_full_report[abc]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_or_bare_sign_is_full_report[x]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_flag_nonnumeric_tokens_all_emit_same_errors_as_zero", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_minus_never_aborts_contrast_neg_digit", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_plus_contrast_sign_digit_plus_one", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_sign_is_clean_n_zero_full_report[+]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_sign_is_clean_n_zero_full_report[-]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_sign_time_only_run_clean[+]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_sign_time_only_run_clean[-]", + "eval.tests.test_sign_only_and_nonnumeric_arguments.test_length_bare_sign_two_sigs_behave_identically", + "eval.tests.test_stream_contract.test_alloc_failure_diagnostic_is_stable_across_large_magnitudes", + "eval.tests.test_stream_contract.test_alloc_failure_diagnostic_matches_golden", + "eval.tests.test_stream_contract.test_large_negative_sizes_sigabrt_with_capacity_message", + "eval.tests.test_stream_contract.test_moderate_negative_sizes_sigsegv_clean_streams", + "eval.tests.test_stream_contract.test_none_of_the_crash_shapes_leaves_timing_header", + "eval.tests.test_stream_contract.test_zero_length_is_not_a_crash" + ] + }, + "generated_module_05": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_stdout_stream_robustness.test_sigpipe_is_signal_13_matches_shell_141", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_stdout_stream_robustness.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_argc_extras.test_empty_string_arguments_after_n_are_ignored", + "eval.tests.test_argc_extras.test_long_numeric_n_reports_exact_n[000123]", + "eval.tests.test_argc_extras.test_long_numeric_n_reports_exact_n[12345]", + "eval.tests.test_argc_extras.test_long_numeric_n_reports_exact_n[9999]", + "eval.tests.test_argc_extras.test_many_extra_arguments_are_ignored", + "eval.tests.test_argc_extras.test_signed_and_alt_zero_forms_reach_n_zero[+0]", + "eval.tests.test_argc_extras.test_signed_and_alt_zero_forms_reach_n_zero[-0]", + "eval.tests.test_argc_extras.test_signed_and_alt_zero_forms_reach_n_zero[0.9]", + "eval.tests.test_argc_extras.test_signed_and_alt_zero_forms_reach_n_zero[00]", + "eval.tests.test_argc_extras.test_signed_and_alt_zero_forms_reach_n_zero[0x7]", + "eval.tests.test_argc_extras.test_space_padded_n_parses_to_integer[ 5 ]", + "eval.tests.test_argc_extras.test_space_padded_n_parses_to_integer[ 5]", + "eval.tests.test_argc_extras.test_space_padded_n_parses_to_integer[5 ]", + "eval.tests.test_argc_extras.test_space_padded_n_parses_to_integer[\\t5\\t]", + "eval.tests.test_argv0_echo.test_symlink_name_does_not_affect_kernel_run", + "eval.tests.test_argv0_echo.test_usage_doubles_leading_dot_slash_argv0", + "eval.tests.test_argv0_echo.test_usage_echoes_custom_symlink_name[app-1.0]", + "eval.tests.test_argv0_echo.test_usage_echoes_custom_symlink_name[kappa.bin]", + "eval.tests.test_argv0_echo.test_usage_echoes_custom_symlink_name[mykern]", + "eval.tests.test_argv0_echo.test_usage_echoes_custom_symlink_name[spmv_demo]", + "eval.tests.test_argv0_echo.test_usage_echoes_relative_argv0[runner]", + "eval.tests.test_argv0_echo.test_usage_echoes_relative_argv0[toy]", + "eval.tests.test_argv0_echo.test_usage_echoes_relative_argv0[xpy]", + "eval.tests.test_argv0_echo.test_usage_writes_only_usage_for_symlink_name[a]", + "eval.tests.test_argv0_echo.test_usage_writes_only_usage_for_symlink_name[b]", + "eval.tests.test_argv0_echo.test_usage_writes_only_usage_for_symlink_name[c]", + "eval.tests.test_boundaries.test_empty_n_token_is_zero", + "eval.tests.test_boundaries.test_extra_arguments_ignored", + "eval.tests.test_boundaries.test_large_n_structured_output", + "eval.tests.test_boundaries.test_n_zero_has_empty_error_lists", + "eval.tests.test_boundaries.test_negative_n_segfaults", + "eval.tests.test_boundaries.test_whitespace_quoted_n_still_atoi", + "eval.tests.test_crash_paths.test_non_numeric_single_token_crashes[+]", + "eval.tests.test_crash_paths.test_non_numeric_single_token_crashes[--]", + "eval.tests.test_crash_paths.test_non_numeric_single_token_crashes[-]", + "eval.tests.test_crash_paths.test_non_numeric_single_token_crashes[]", + "eval.tests.test_crash_paths.test_non_numeric_single_token_crashes[a]", + "eval.tests.test_crash_paths.test_small_negative_n_crashes_in_time_only_mode[1]", + "eval.tests.test_crash_paths.test_small_negative_n_crashes_in_time_only_mode[2]", + "eval.tests.test_crash_paths.test_small_negative_n_crashes_in_time_only_mode[3]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[2]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[3]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[4]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[6]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[7]", + "eval.tests.test_crash_paths.test_small_negative_n_segfaults_with_empty_output[9]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[11]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[14]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[16]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[21]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[25]", + "eval.tests.test_determinism.test_error_values_identical_across_two_runs[40]", + "eval.tests.test_determinism.test_error_values_stay_in_range_everywhere[13]", + "eval.tests.test_determinism.test_error_values_stay_in_range_everywhere[19]", + "eval.tests.test_determinism.test_error_values_stay_in_range_everywhere[22]", + "eval.tests.test_determinism.test_output_length_scales_with_n_consistently", + "eval.tests.test_determinism.test_runtime_values_present_but_vary_across_runs", + "eval.tests.test_determinism.test_stdout_is_byte_identical_after_normalizing_runtime[11]", + "eval.tests.test_determinism.test_stdout_is_byte_identical_after_normalizing_runtime[16]", + "eval.tests.test_determinism.test_stdout_is_byte_identical_after_normalizing_runtime[25]", + "eval.tests.test_exact_stdout_golden.test_all_three_blocks_byte_identical_after_runtime_norm[10]", + "eval.tests.test_exact_stdout_golden.test_all_three_blocks_byte_identical_after_runtime_norm[20]", + "eval.tests.test_exact_stdout_golden.test_all_three_blocks_byte_identical_after_runtime_norm[2]", + "eval.tests.test_exact_stdout_golden.test_all_three_blocks_byte_identical_after_runtime_norm[6]", + "eval.tests.test_exact_stdout_golden.test_error_values_equal_golden_across_blocks[13]", + "eval.tests.test_exact_stdout_golden.test_error_values_equal_golden_across_blocks[1]", + "eval.tests.test_exact_stdout_golden.test_error_values_equal_golden_across_blocks[25]", + "eval.tests.test_exact_stdout_golden.test_error_values_equal_golden_across_blocks[7]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[10]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[1]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[2]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[3]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[4]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[5]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[6]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[7]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[8]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout[9]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[11]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[12]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[13]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[14]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[15]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[16]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[17]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[18]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_extended[20]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_large[24]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_large[25]", + "eval.tests.test_exact_stdout_golden.test_full_stdout_matches_golden_layout_large[32]", + "eval.tests.test_kokkos_threads_env.test_abort_fires_even_for_no_argument_invocation", + "eval.tests.test_kokkos_threads_env.test_abort_independent_of_n_and_time_only[args0]", + "eval.tests.test_kokkos_threads_env.test_abort_independent_of_n_and_time_only[args1]", + "eval.tests.test_kokkos_threads_env.test_abort_independent_of_n_and_time_only[args2]", + "eval.tests.test_kokkos_threads_env.test_abort_independent_of_n_and_time_only[args3]", + "eval.tests.test_kokkos_threads_env.test_alphanumeric_prefix_mixed_tokens_rejected[abc123]", + "eval.tests.test_kokkos_threads_env.test_alphanumeric_prefix_mixed_tokens_rejected[five]", + "eval.tests.test_kokkos_threads_env.test_alphanumeric_prefix_mixed_tokens_rejected[threads]", + "eval.tests.test_kokkos_threads_env.test_alphanumeric_prefix_mixed_tokens_rejected[xyz]", + "eval.tests.test_kokkos_threads_env.test_non_integer_threads_abort_before_output[]", + "eval.tests.test_kokkos_threads_env.test_non_integer_threads_abort_before_output[abc123]", + "eval.tests.test_kokkos_threads_env.test_non_integer_threads_abort_before_output[abc]", + "eval.tests.test_kokkos_threads_env.test_non_integer_threads_abort_before_output[threads]", + "eval.tests.test_kokkos_threads_env.test_thread_count_below_one_aborts[-10]", + "eval.tests.test_kokkos_threads_env.test_thread_count_below_one_aborts[-1]", + "eval.tests.test_kokkos_threads_env.test_thread_count_below_one_aborts[0]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_runs_kernels_normally[1]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_runs_kernels_normally[4]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_runs_kernels_normally[64]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_runs_kernels_normally[8]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_runs_kernels_normally[999999]", + "eval.tests.test_kokkos_threads_env.test_valid_thread_count_with_no_args_still_prints_usage", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[1024]", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[17]", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[256]", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[33]", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[512]", + "eval.tests.test_large_n_and_zero.test_error_row_count_scales_exactly_three_times_n[64]", + "eval.tests.test_large_n_and_zero.test_n_zero_error_blocks_have_zero_rows_but_exit_zero", + "eval.tests.test_large_n_and_zero.test_time_only_large_n_echoes_three_correct_runtime_lines[1024]", + "eval.tests.test_large_n_and_zero.test_time_only_large_n_echoes_three_correct_runtime_lines[2048]", + "eval.tests.test_large_n_and_zero.test_time_only_large_n_echoes_three_correct_runtime_lines[512]", + "eval.tests.test_large_n_and_zero.test_time_only_large_n_runtime_values_are_nonnegative_floats[1024]", + "eval.tests.test_large_n_and_zero.test_time_only_large_n_runtime_values_are_nonnegative_floats[512]", + "eval.tests.test_large_n_and_zero.test_time_only_n_zero_emits_three_n_zero_runtime_lines", + "eval.tests.test_large_n_and_zero.test_time_only_suppresses_error_rows_at_every_size[0]", + "eval.tests.test_large_n_and_zero.test_time_only_suppresses_error_rows_at_every_size[1]", + "eval.tests.test_large_n_and_zero.test_time_only_suppresses_error_rows_at_every_size[256]", + "eval.tests.test_large_n_and_zero.test_time_only_suppresses_error_rows_at_every_size[512]", + "eval.tests.test_large_n_and_zero.test_time_only_suppresses_error_rows_at_every_size[8]", + "eval.tests.test_path_forms.test_bare_multi_segment_argv0_echoed_verbatim_in_usage[a/b/c/d/e/name]", + "eval.tests.test_path_forms.test_bare_multi_segment_argv0_echoed_verbatim_in_usage[a/b/c/name]", + "eval.tests.test_path_forms.test_bare_multi_segment_argv0_echoed_verbatim_in_usage[a/b/name]", + "eval.tests.test_path_forms.test_bare_multi_segment_argv0_echoed_verbatim_in_usage[a/name]", + "eval.tests.test_path_forms.test_bare_multi_segment_argv0_echoed_verbatim_in_usage[deep/ly/nest/ed/kernel]", + "eval.tests.test_path_forms.test_dot_segment_preserved_verbatim_in_usage[./a/name]", + "eval.tests.test_path_forms.test_dot_segment_preserved_verbatim_in_usage[a/./b/./name]", + "eval.tests.test_path_forms.test_dot_segment_preserved_verbatim_in_usage[a/./name]", + "eval.tests.test_path_forms.test_dot_segment_preserved_verbatim_in_usage[a/b/./c/name]", + "eval.tests.test_path_forms.test_dot_segment_preserved_verbatim_in_usage[x/y/./z/name]", + "eval.tests.test_path_forms.test_multi_segment_path_still_runs_kernels_normally", + "eval.tests.test_path_forms.test_multi_segment_tuple_isolated_per_worker[a/b/c/name]", + "eval.tests.test_path_forms.test_multi_segment_tuple_isolated_per_worker[a/name]", + "eval.tests.test_path_forms.test_multi_segment_tuple_isolated_per_worker[x/y/./name]", + "eval.tests.test_relative_errors.test_blank_line_separates_error_blocks", + "eval.tests.test_relative_errors.test_error_values_in_valid_relerr_range", + "eval.tests.test_relative_errors.test_first_element_error_is_deterministic", + "eval.tests.test_relative_errors.test_golden_error_values_match[10]", + "eval.tests.test_relative_errors.test_golden_error_values_match[12]", + "eval.tests.test_relative_errors.test_golden_error_values_match[15]", + "eval.tests.test_relative_errors.test_golden_error_values_match[1]", + "eval.tests.test_relative_errors.test_golden_error_values_match[2]", + "eval.tests.test_relative_errors.test_golden_error_values_match[3]", + "eval.tests.test_relative_errors.test_golden_error_values_match[4]", + "eval.tests.test_relative_errors.test_golden_error_values_match[5]", + "eval.tests.test_relative_errors.test_golden_error_values_match[6]", + "eval.tests.test_relative_errors.test_golden_error_values_match[7]", + "eval.tests.test_relative_errors.test_golden_error_values_match[8]", + "eval.tests.test_relative_errors.test_golden_error_values_match[9]", + "eval.tests.test_relative_errors.test_number_of_error_rows_scales_with_n", + "eval.tests.test_relative_errors.test_three_blocks_share_identical_errors[10]", + "eval.tests.test_relative_errors.test_three_blocks_share_identical_errors[15]", + "eval.tests.test_relative_errors.test_three_blocks_share_identical_errors[1]", + "eval.tests.test_relative_errors.test_three_blocks_share_identical_errors[5]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[15]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[1]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[256]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[3]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[64]", + "eval.tests.test_runtime_blocks.test_exactly_three_blocks[8]", + "eval.tests.test_runtime_blocks.test_runtime_line_format_precise", + "eval.tests.test_runtime_blocks.test_runtime_value_is_positive_float[1]", + "eval.tests.test_runtime_blocks.test_runtime_value_is_positive_float[20]", + "eval.tests.test_runtime_blocks.test_runtime_value_is_positive_float[7]", + "eval.tests.test_runtime_blocks.test_time_only_negative_is_truthy", + "eval.tests.test_runtime_blocks.test_time_only_truthy_suppresses_error_sections[-1]", + "eval.tests.test_runtime_blocks.test_time_only_truthy_suppresses_error_sections[1]", + "eval.tests.test_runtime_blocks.test_time_only_truthy_suppresses_error_sections[2]", + "eval.tests.test_runtime_blocks.test_time_only_zero_emits_error_sections[0.0]", + "eval.tests.test_runtime_blocks.test_time_only_zero_emits_error_sections[0]", + "eval.tests.test_runtime_blocks.test_time_only_zero_emits_error_sections[None]", + "eval.tests.test_stdin_ignored.test_stdin_and_no_stdin_agree_bytewise[11]", + "eval.tests.test_stdin_ignored.test_stdin_and_no_stdin_agree_bytewise[25]", + "eval.tests.test_stdin_ignored.test_stdin_and_no_stdin_agree_bytewise[3]", + "eval.tests.test_stdin_ignored.test_stdin_input_is_ignored[0\\n]", + "eval.tests.test_stdin_ignored.test_stdin_input_is_ignored[1 2 3\\n4 5 6\\n]", + "eval.tests.test_stdin_ignored.test_stdin_input_is_ignored[\\xff\\xfe binary-ish\\r\\n]", + "eval.tests.test_stdin_ignored.test_stdin_input_is_ignored[not-a-number\\ngarbage line\\n]", + "eval.tests.test_stdin_ignored.test_stdin_without_newline_does_not_hang", + "eval.tests.test_stdout_stream_robustness.test_closed_read_end_kills_with_sigpipe[1000-1]", + "eval.tests.test_stdout_stream_robustness.test_closed_read_end_kills_with_sigpipe[64-0]", + "eval.tests.test_stdout_stream_robustness.test_closed_read_end_kills_with_sigpipe[8-1]", + "eval.tests.test_stdout_stream_robustness.test_no_argument_usage_to_sink_still_returns_one", + "eval.tests.test_stdout_stream_robustness.test_sigpipe_happens_before_any_usage_output", + "eval.tests.test_stdout_stream_robustness.test_sigpipe_is_signal_13_matches_shell_141", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_runs_kernels_and_exits_zero[1-0]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_runs_kernels_and_exits_zero[256-1]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_runs_kernels_and_exits_zero[5-1]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_runs_kernels_and_exits_zero[64-0]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_time_only_variants[0-0]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_time_only_variants[1-0]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_time_only_variants[1-1]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_time_only_variants[100-0]", + "eval.tests.test_stdout_stream_robustness.test_stdout_to_sink_time_only_variants[100-1]", + "eval.tests.test_stream_and_format.test_crash_emits_no_stdout", + "eval.tests.test_stream_and_format.test_each_block_labels_its_own_n", + "eval.tests.test_stream_and_format.test_error_header_and_rows_match_golden", + "eval.tests.test_stream_and_format.test_error_rows_come_immediately_after_header", + "eval.tests.test_stream_and_format.test_noarg_usage_on_stdout_not_stderr", + "eval.tests.test_stream_and_format.test_success_writes_nothing_to_stderr", + "eval.tests.test_stream_and_format.test_three_blocks_in_fixed_order", + "eval.tests.test_stream_and_format.test_time_only_runtime_only_structure", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[ 1 ]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[+1]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[-1]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[-5]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[10]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[1]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[2]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[3]", + "eval.tests.test_time_only_mode.test_nonzero_time_only_yields_runtime_only[7]", + "eval.tests.test_time_only_mode.test_time_only_expression_lines_strict_format", + "eval.tests.test_time_only_mode.test_time_only_nonzero_with_non_numeric_prefix_is_truthy", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[ 0 ]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[+0]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[000]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[00]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[0]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[0x]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[]", + "eval.tests.test_time_only_mode.test_zero_time_only_yields_error_sections[abc]", + "eval.tests.test_type_labels.test_each_runtime_line_carries_a_type_label[11]", + "eval.tests.test_type_labels.test_each_runtime_line_carries_a_type_label[1]", + "eval.tests.test_type_labels.test_each_runtime_line_carries_a_type_label[20]", + "eval.tests.test_type_labels.test_each_runtime_line_carries_a_type_label[5]", + "eval.tests.test_type_labels.test_header_and_runtime_share_the_same_type_token[25]", + "eval.tests.test_type_labels.test_header_and_runtime_share_the_same_type_token[3]", + "eval.tests.test_type_labels.test_header_and_runtime_share_the_same_type_token[9]", + "eval.tests.test_type_labels.test_type_token_is_nonempty_for_all_blocks", + "eval.tests.test_usage_and_argc.test_floating_point_n_truncated_by_atoi", + "eval.tests.test_usage_and_argc.test_leading_plus_n_accepted", + "eval.tests.test_usage_and_argc.test_no_argument_prints_exact_usage_line", + "eval.tests.test_usage_and_argc.test_no_argument_writes_no_runtime_output", + "eval.tests.test_usage_and_argc.test_non_numeric_n_interpreted_as_zero", + "eval.tests.test_usage_and_argc.test_partial_numeric_prefix_uses_leading_digits", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[--help]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[-h]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[-v]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[100000]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[100]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[1]", + "eval.tests.test_usage_and_argc.test_single_argument_segfaults[5]" + ] + }, + "generated_module_06": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_xpy_boundary.test_large_length_three_identical_error_columns[1024]", + "eval.tests.test_xpy_boundary.test_large_length_three_identical_error_columns[262144]", + "eval.tests.test_xpy_boundary.test_large_length_three_identical_error_columns[65536]", + "eval.tests.test_xpy_boundary.test_large_relative_errors_pairwise_independent[128]", + "eval.tests.test_xpy_boundary.test_large_relative_errors_pairwise_independent[16]", + "eval.tests.test_xpy_boundary.test_large_relative_errors_pairwise_independent[256]", + "eval.tests.test_xpy_boundary.test_single_element_error_is_finite[1]", + "eval.tests.test_xpy_boundary.test_single_element_error_is_finite[2]", + "eval.tests.test_xpy_boundary.test_unit_length_error_column_matches_golden", + "eval.tests.test_xpy_boundary.test_zero_length_has_exactly_empty_error_columns", + "eval.tests.test_xpy_crash.test_negative_length_crashes_without_success_output[-10]", + "eval.tests.test_xpy_crash.test_negative_length_crashes_without_success_output[-1]", + "eval.tests.test_xpy_crash.test_negative_length_crashes_without_success_output[-3]", + "eval.tests.test_xpy_crash.test_single_argument_crashes_without_success_output[16]", + "eval.tests.test_xpy_crash.test_single_argument_crashes_without_success_output[3]", + "eval.tests.test_xpy_crash.test_single_argument_crashes_without_success_output[4]", + "eval.tests.test_xpy_crash.test_single_argument_crashes_without_success_output[]", + "eval.tests.test_xpy_determinism.test_error_stream_is_deterministic_across_processes", + "eval.tests.test_xpy_determinism.test_n10_golden_error_column_matches_golden_data", + "eval.tests.test_xpy_determinism.test_repeated_invocation_identical_for_unpinned_n[12]", + "eval.tests.test_xpy_determinism.test_repeated_invocation_identical_for_unpinned_n[5]", + "eval.tests.test_xpy_determinism.test_three_blocks_each_accord_seven_layout[11]", + "eval.tests.test_xpy_determinism.test_three_blocks_each_accord_seven_layout[13]", + "eval.tests.test_xpy_determinism.test_three_blocks_each_accord_seven_layout[6]", + "eval.tests.test_xpy_determinism.test_three_blocks_each_accord_seven_layout[7]", + "eval.tests.test_xpy_golden_errors.test_error_stream_repeats_identically_across_type_blocks[2]", + "eval.tests.test_xpy_golden_errors.test_error_stream_repeats_identically_across_type_blocks[5]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[10]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[11]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[12]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[1]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[2]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[3]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[4]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[5]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[6]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[7]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[8]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_match_golden_signature[9]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_none_are_negative[1]", + "eval.tests.test_xpy_golden_errors.test_relative_errors_none_are_negative[3]", + "eval.tests.test_xpy_golden_errors.test_time_only_completely_suppresses_error_lines[2]", + "eval.tests.test_xpy_golden_errors.test_time_only_completely_suppresses_error_lines[8]", + "eval.tests.test_xpy_output.test_block_headers_echo_n_verbatim", + "eval.tests.test_xpy_output.test_error_header_precedes_error_lines_in_each_block", + "eval.tests.test_xpy_output.test_rel_error_column_exactly_matches_golden[1]", + "eval.tests.test_xpy_output.test_rel_error_column_exactly_matches_golden[4]", + "eval.tests.test_xpy_output.test_rel_error_column_exactly_matches_golden[9]", + "eval.tests.test_xpy_output.test_three_type_blocks_each_with_positive_runtime[16]", + "eval.tests.test_xpy_output.test_three_type_blocks_each_with_positive_runtime[1]", + "eval.tests.test_xpy_output.test_three_type_blocks_each_with_positive_runtime[2]", + "eval.tests.test_xpy_output.test_three_type_blocks_each_with_positive_runtime[64]", + "eval.tests.test_xpy_output.test_three_type_blocks_each_with_positive_runtime[8]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[ 7-7]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[+-0]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[+9-9]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[004-4]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[010-10]", + "eval.tests.test_xpy_parsing.test_atoi_leading_and_sign_edge_cases[12abc-12]", + "eval.tests.test_xpy_parsing.test_atoi_non_numeric_yields_zero[-x-0]", + "eval.tests.test_xpy_parsing.test_atoi_non_numeric_yields_zero[.5-0]", + "eval.tests.test_xpy_parsing.test_atoi_non_numeric_yields_zero[0x10-0]", + "eval.tests.test_xpy_parsing.test_atoi_non_numeric_yields_zero[999xyz-999]", + "eval.tests.test_xpy_parsing.test_atoi_non_numeric_yields_zero[abc-0]", + "eval.tests.test_xpy_parsing.test_numeric_parses_match_token[1]", + "eval.tests.test_xpy_parsing.test_numeric_parses_match_token[255]", + "eval.tests.test_xpy_parsing.test_numeric_parses_match_token[31]", + "eval.tests.test_xpy_parsing.test_numeric_parses_match_token[9]", + "eval.tests.test_xpy_runtime_format.test_header_order_two_params_stable_in_time_only", + "eval.tests.test_xpy_runtime_format.test_runtime_figures_are_finite_and_nonnegative[16]", + "eval.tests.test_xpy_runtime_format.test_runtime_figures_are_finite_and_nonnegative[2]", + "eval.tests.test_xpy_runtime_format.test_runtime_header_format_holds_in_time_only_mode[1]", + "eval.tests.test_xpy_runtime_format.test_runtime_header_format_holds_in_time_only_mode[32]", + "eval.tests.test_xpy_runtime_format.test_runtime_header_format_holds_in_time_only_mode[4]", + "eval.tests.test_xpy_runtime_format.test_runtime_header_matches_exact_scientific_format", + "eval.tests.test_xpy_structure.test_error_blocks_form_contiguous_partition[2]", + "eval.tests.test_xpy_structure.test_error_blocks_form_contiguous_partition[4]", + "eval.tests.test_xpy_structure.test_error_blocks_form_contiguous_partition[8]", + "eval.tests.test_xpy_structure.test_error_data_uses_exact_comma_space_separator[12]", + "eval.tests.test_xpy_structure.test_error_data_uses_exact_comma_space_separator[1]", + "eval.tests.test_xpy_structure.test_error_data_uses_exact_comma_space_separator[6]", + "eval.tests.test_xpy_structure.test_error_mode_first_line_is_header_first_block[2]", + "eval.tests.test_xpy_structure.test_error_mode_first_line_is_header_first_block[3]", + "eval.tests.test_xpy_structure.test_error_mode_first_line_is_header_first_block[6]", + "eval.tests.test_xpy_structure.test_error_mode_first_line_is_header_first_block[8]", + "eval.tests.test_xpy_structure.test_error_mode_has_exact_two_blank_lines_per_block[2]", + "eval.tests.test_xpy_structure.test_error_mode_has_exact_two_blank_lines_per_block[3]", + "eval.tests.test_xpy_structure.test_error_mode_has_exact_two_blank_lines_per_block[5]", + "eval.tests.test_xpy_structure.test_error_mode_has_exact_two_blank_lines_per_block[9]", + "eval.tests.test_xpy_structure.test_error_mode_total_line_count_ties_to_n[11]", + "eval.tests.test_xpy_structure.test_error_mode_total_line_count_ties_to_n[3]", + "eval.tests.test_xpy_structure.test_error_mode_total_line_count_ties_to_n[5]", + "eval.tests.test_xpy_structure.test_error_mode_total_line_count_ties_to_n[7]", + "eval.tests.test_xpy_structure.test_every_header_type_tag_is_literal_f[16]", + "eval.tests.test_xpy_structure.test_every_header_type_tag_is_literal_f[1]", + "eval.tests.test_xpy_structure.test_every_header_type_tag_is_literal_f[4]", + "eval.tests.test_xpy_structure.test_every_header_type_tag_is_literal_f[8]", + "eval.tests.test_xpy_structure.test_no_line_carries_trailing_whitespace[10]", + "eval.tests.test_xpy_structure.test_no_line_carries_trailing_whitespace[20]", + "eval.tests.test_xpy_structure.test_no_line_carries_trailing_whitespace[4]", + "eval.tests.test_xpy_structure.test_relative_errors_label_occurs_exactly_three_times[12]", + "eval.tests.test_xpy_structure.test_relative_errors_label_occurs_exactly_three_times[1]", + "eval.tests.test_xpy_structure.test_relative_errors_label_occurs_exactly_three_times[6]", + "eval.tests.test_xpy_structure.test_successful_invocation_writes_nothing_to_stderr[mode_args0]", + "eval.tests.test_xpy_structure.test_successful_invocation_writes_nothing_to_stderr[mode_args1]", + "eval.tests.test_xpy_structure.test_successful_invocation_writes_nothing_to_stderr[mode_args2]", + "eval.tests.test_xpy_structure.test_successful_invocation_writes_nothing_to_stderr[mode_args3]", + "eval.tests.test_xpy_structure.test_time_only_mode_has_no_blank_lines_labels_or_error_lines[2]", + "eval.tests.test_xpy_structure.test_time_only_mode_has_no_blank_lines_labels_or_error_lines[8]", + "eval.tests.test_xpy_structure.test_zero_length_time_only_still_prints_three_headers", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[+0-False]", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[-3-True]", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[0-False]", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[010-True]", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[1-True]", + "eval.tests.test_xpy_time_only.test_time_only_boolean_orthogonal_to_mag_nezero[10-True]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[ 2]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[+5]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[-7]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[1]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[1t]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[42]", + "eval.tests.test_xpy_time_only.test_time_only_nonzero_suppresses_error_blocks[999]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[ 0]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[+0]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[-0]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[000]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[0]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[0t]", + "eval.tests.test_xpy_time_only.test_time_only_zero_equivalent_keeps_error_blocks[]", + "eval.tests.test_xpy_usage.test_atoi_semantics_reflected_in_header[argv0-0]", + "eval.tests.test_xpy_usage.test_atoi_semantics_reflected_in_header[argv1-0]", + "eval.tests.test_xpy_usage.test_atoi_semantics_reflected_in_header[argv2-0]", + "eval.tests.test_xpy_usage.test_atoi_semantics_reflected_in_header[argv3-3]", + "eval.tests.test_xpy_usage.test_exactly_three_runtime_headers_with_golden_errors", + "eval.tests.test_xpy_usage.test_large_time_only_flag_is_truthy", + "eval.tests.test_xpy_usage.test_no_arguments_prints_exact_usage[args0]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv0]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv1]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv2]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv3]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv4]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv5]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv6]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv7]", + "eval.tests.test_xpy_usage.test_valid_two_arg_invocations_succeed[argv8]" + ] + } + }, + "commit": "4a10bcb94acb1ead8094d520f3040e5dd99f0c17", + "data_source": "synthetic_programgym", + "difficulty": "", + "difficulty_score": null, + "eval_clean_hashes": [ + "dcf0f851d42b166003bb1e93e6a5f8741fae0bd481a02d24f8129dbb6d0acb89" + ], + "input_record": { + "commit": "4a10bcb94acb1ead8094d520f3040e5dd99f0c17", + "difficulty": "medium", + "difficulty_code_lines": 229951, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 229951, + "difficulty_runtime_deps": 2, + "difficulty_score": 3.838756557273066, + "difficulty_test_code_lines": 78562, + "full_name": "kokkos/kokkos-kernels", + "input_joern_zip": "cpp_joern/kokkos__kokkos-kernels.zip", + "joern_status": true, + "joern_time": 80.79668102297, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 311, + "similarity": 0.49694329500198364 + }, + { + "pb_fullname": "OSGeo/PROJ", + "rank": 883, + "similarity": 0.38859570026397705 + } + ], + "repo_path": "cpp/kokkos__kokkos-kernels", + "source": "commit:4a10bcb94acb1ead8094d520f3040e5dd99f0c17", + "status": "done", + "url": "https://github.com/kokkos/kokkos-kernels" + }, + "instance_id": "kokkos__kokkos-kernels.4a10bcb", + "language": "cpp", + "module_iterations": [], + "repository": "kokkos/kokkos-kernels" +} diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/test.sh b/kokkos--kokkos-kernels.4a10bcb/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kokkos--kokkos-kernels.4a10bcb/tests/workspace.tar.gz b/kokkos--kokkos-kernels.4a10bcb/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..de0b8b0c0121d795bc915a47ff548dee962203e8 --- /dev/null +++ b/kokkos--kokkos-kernels.4a10bcb/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a86beece3f698b5c705bf779e6385056052273ee9260313bd46edb9aa13190eb +size 11505 diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/Dockerfile b/kongaskristjan--fire-hpp.7d000fd/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..cd042aa1c8902da43f5e168d272841107895d27b --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/docker-compose.yaml b/kongaskristjan--fire-hpp.7d000fd/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/download.sh b/kongaskristjan--fire-hpp.7d000fd/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..a7edc7b0a7e6d0bc26837a6b1b6200843016d833 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/download.sh @@ -0,0 +1,71 @@ +#!/usr/bin/env bash +# ============================================================================ +# download.sh — ProgramGym network/download stage for fire-hpp (C++) +# ============================================================================ +# fire-hpp is a single-header C++ command-line argument-parsing library +# (include/fire-hpp/fire.hpp). The only build dependencies are a C++ compiler, +# CMake, and libstdc++ header/support — all of which are already installed in +# the base image (g++ 13.3.0, cmake 3.31.12, make 4.3). No third-party package, +# source archive, or vendored dependency is needed to build the example +# programs, so this script performs NO package installation, prefetching, or +# network access. +# +# Execution model: this file is sourced via `source /source_ro/download.sh` +# from a read-only repository mount (only download.sh itself is available; the +# rest of the source tree is not). It MUST therefore be a standalone, source- +# safe script: +# - It keeps exported variables in the current shell. +# - It takes no positional arguments. +# - It never uses `exit` in normal control flow. +# - It performs NO build step (no compile, link, test, package, or configure). +# - It reads NO repository build/config/source files. +# +# It is idempotent: sourcing it repeatedly has no additional effect. + +set -e + +# --------------------------------------------------------------------------- +# 1. Verify that the required toolchain components exist in the environment. +# (command -v emits no stderr for missing commands, so no redirect is used.) +# --------------------------------------------------------------------------- +if ! command -v g++; then + echo "download.sh: required 'g++' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +if ! command -v cmake; then + echo "download.sh: required 'cmake' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +if ! command -v make; then + echo "download.sh: required 'make' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +# --------------------------------------------------------------------------- +# 2. No dependency downloads are required for this header-only project. +# Leave a placeholder here so future maintainers know there is intentionally +# nothing to fetch. +# --------------------------------------------------------------------------- + +# --------------------------------------------------------------------------- +# 3. Export the build environment that build.sh relies on. +# --------------------------------------------------------------------------- +export FIRE_HPP_BUILD_DIR="build" +export FIRE_HPP_CMAKE_GENERATOR="Unix Makefiles" +export FIRE_HPP_TARGET="all_combinations" + +echo "download.sh: toolchain verified; no downloads required for fire-hpp." diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/executable b/kongaskristjan--fire-hpp.7d000fd/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..a07a559417126a35c6928cc8f7ff8407297038cb --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3e9f481987a57735623499ee79f362fa6bdf21acbd58058d02ad9a02dda60d7 +size 2877880 diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/harbor_configure_apt_mirror.sh b/kongaskristjan--fire-hpp.7d000fd/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/harbor_prepare_download_env.sh b/kongaskristjan--fire-hpp.7d000fd/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kongaskristjan--fire-hpp.7d000fd/environment/workspace.tar.gz b/kongaskristjan--fire-hpp.7d000fd/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..94b50f898ab748d56878bb88850ccc9756b2c74c --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e312194e56a3c45fc74144bda8ef8c6b002bb52069176769a0987eb48bc7a5a +size 24104 diff --git a/kongaskristjan--fire-hpp.7d000fd/instruction.md b/kongaskristjan--fire-hpp.7d000fd/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kongaskristjan--fire-hpp.7d000fd/solution/solve.sh b/kongaskristjan--fire-hpp.7d000fd/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kongaskristjan--fire-hpp.7d000fd/task.toml b/kongaskristjan--fire-hpp.7d000fd/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c4422251c4e0be5ada9e66b8f8c9250a16dea157 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kongaskristjan--fire-hpp.7d000fd" +description = "Synthetic ProgramGym cleanroom reconstruction task for kongaskristjan/fire-hpp" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kongaskristjan__fire-hpp.7d000fd" +repository = "kongaskristjan/fire-hpp" +commit = "7d000fd65375503bc7c8bb2add9c97b0f0110613" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.1586639808139894 +test_branches = 2 +test_count = 206 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/Dockerfile b/kongaskristjan--fire-hpp.7d000fd/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ae6071510c9375ad35caf40d5f0fc02507509a77 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_module_01.tar.gz b/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7f7480e9d51e10d9b5792e8d2acaebde7a75ea9b --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acfe7ceb74d9cf17f813db402791ac8ca8ea4a81d41dffe4bf218a5b79e6cd22 +size 12123 diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_upstream.tar.gz b/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..56612cf3389fa7f20047031324680f98acee0d9b --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:330939d924b28160aa5e3fa7874ee6f1754cb834b4322b1c128c001a13bc46ff +size 2560 diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/docker-compose.yaml b/kongaskristjan--fire-hpp.7d000fd/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/download.sh b/kongaskristjan--fire-hpp.7d000fd/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..a7edc7b0a7e6d0bc26837a6b1b6200843016d833 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/download.sh @@ -0,0 +1,71 @@ +#!/usr/bin/env bash +# ============================================================================ +# download.sh — ProgramGym network/download stage for fire-hpp (C++) +# ============================================================================ +# fire-hpp is a single-header C++ command-line argument-parsing library +# (include/fire-hpp/fire.hpp). The only build dependencies are a C++ compiler, +# CMake, and libstdc++ header/support — all of which are already installed in +# the base image (g++ 13.3.0, cmake 3.31.12, make 4.3). No third-party package, +# source archive, or vendored dependency is needed to build the example +# programs, so this script performs NO package installation, prefetching, or +# network access. +# +# Execution model: this file is sourced via `source /source_ro/download.sh` +# from a read-only repository mount (only download.sh itself is available; the +# rest of the source tree is not). It MUST therefore be a standalone, source- +# safe script: +# - It keeps exported variables in the current shell. +# - It takes no positional arguments. +# - It never uses `exit` in normal control flow. +# - It performs NO build step (no compile, link, test, package, or configure). +# - It reads NO repository build/config/source files. +# +# It is idempotent: sourcing it repeatedly has no additional effect. + +set -e + +# --------------------------------------------------------------------------- +# 1. Verify that the required toolchain components exist in the environment. +# (command -v emits no stderr for missing commands, so no redirect is used.) +# --------------------------------------------------------------------------- +if ! command -v g++; then + echo "download.sh: required 'g++' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +if ! command -v cmake; then + echo "download.sh: required 'cmake' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +if ! command -v make; then + echo "download.sh: required 'make' was not found in the environment." >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi + +# --------------------------------------------------------------------------- +# 2. No dependency downloads are required for this header-only project. +# Leave a placeholder here so future maintainers know there is intentionally +# nothing to fetch. +# --------------------------------------------------------------------------- + +# --------------------------------------------------------------------------- +# 3. Export the build environment that build.sh relies on. +# --------------------------------------------------------------------------- +export FIRE_HPP_BUILD_DIR="build" +export FIRE_HPP_CMAKE_GENERATOR="Unix Makefiles" +export FIRE_HPP_TARGET="all_combinations" + +echo "download.sh: toolchain verified; no downloads required for fire-hpp." diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/executable b/kongaskristjan--fire-hpp.7d000fd/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..a07a559417126a35c6928cc8f7ff8407297038cb --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3e9f481987a57735623499ee79f362fa6bdf21acbd58058d02ad9a02dda60d7 +size 2877880 diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/harbor_configure_apt_mirror.sh b/kongaskristjan--fire-hpp.7d000fd/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/harbor_prepare_download_env.sh b/kongaskristjan--fire-hpp.7d000fd/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/programgym_evaluator.py b/kongaskristjan--fire-hpp.7d000fd/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/programgym_task.json b/kongaskristjan--fire-hpp.7d000fd/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..7139d2952601eba53c0a159f40dafabac82a4d6f --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/programgym_task.json @@ -0,0 +1,321 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[-1e5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[-3.5E5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[1E5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[1e4933000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[1e5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_equals_form[8.9e4999]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_space_form[-1e5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_space_form[1E5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_overflow_space_form[1e5000]", + "eval.tests.test_argv_extended.test_def_r_long_double_short_name_overflow", + "eval.tests.test_argv_extended.test_def_r_overflow_distinct_from_double_overflow", + "eval.tests.test_argv_extended.test_double_dash_forces_flag_tokens_into_positional[extra0-invalid positional arguments --bogus --other]", + "eval.tests.test_argv_extended.test_double_dash_forces_flag_tokens_into_positional[extra1-invalid positional argument -x]", + "eval.tests.test_argv_extended.test_double_dash_forces_flag_tokens_into_positional[extra2-invalid positional argument --flag]", + "eval.tests.test_argv_extended.test_double_dash_second_becomes_positional_value", + "eval.tests.test_argv_extended.test_flag_false_value_rejected", + "eval.tests.test_argv_extended.test_flag_positional_flag_ordering_accepted", + "eval.tests.test_argv_extended.test_flag_then_double_dash_then_flag_value", + "eval.tests.test_argv_extended.test_help_flag_disabled_after_double_dash", + "eval.tests.test_argv_extended.test_help_group_usage_line_stable[-fhf]", + "eval.tests.test_argv_extended.test_help_group_usage_line_stable[-fhfg]", + "eval.tests.test_argv_extended.test_help_group_usage_line_stable[-hf]", + "eval.tests.test_argv_extended.test_help_via_single_hyphen_group[-fgh]", + "eval.tests.test_argv_extended.test_help_via_single_hyphen_group[-fh]", + "eval.tests.test_argv_extended.test_help_via_single_hyphen_group[-fhi]", + "eval.tests.test_argv_extended.test_help_via_single_hyphen_group[-hi]", + "eval.tests.test_argv_extended.test_long_double_overflow_short_space_form", + "eval.tests.test_argv_extended.test_optional_string_space_value_then_flag", + "eval.tests.test_argv_extended.test_single_hyphen_digit_token_is_positional_value", + "eval.tests.test_argv_extended.test_space_equated_i_duplicate_detected", + "eval.tests.test_argv_extended.test_string_value_contains_equals", + "eval.tests.test_argv_extended.test_three_hyphen_named_shape_consumed_as_positional", + "eval.tests.test_argv_extended.test_too_short_long_name_rejected", + "eval.tests.test_argv_extended.test_two_extra_positionals_plural", + "eval.tests.test_argv_parsing.test_double_dash_forces_positional", + "eval.tests.test_argv_parsing.test_double_dash_terminates_named_parsing[tail0]", + "eval.tests.test_argv_parsing.test_double_dash_terminates_named_parsing[tail1]", + "eval.tests.test_argv_parsing.test_duplicate_named_argument_runs_message", + "eval.tests.test_argv_parsing.test_duplicate_positional_overtop_rejected", + "eval.tests.test_argv_parsing.test_named_args_across_all_types", + "eval.tests.test_argv_parsing.test_named_argument_appears_before_required_positional_error", + "eval.tests.test_argv_parsing.test_named_then_positional_order_independent", + "eval.tests.test_argv_parsing.test_named_value_space_equated", + "eval.tests.test_argv_parsing.test_positional_after_named_accepted", + "eval.tests.test_argv_parsing.test_require_all_required_satisfied_correct_order", + "eval.tests.test_argv_parsing.test_short_hyphen_group_with_missing_value_arg", + "eval.tests.test_argv_parsing.test_three_hyphen_token_become_positional", + "eval.tests.test_argv_parsing.test_unknown_long_argument_rejected", + "eval.tests.test_argv_parsing.test_unknown_long_flag_rejected", + "eval.tests.test_entrypoint.test_executable_runs_and_exits_zero_silently", + "eval.tests.test_entrypoint.test_flag_sets_bool_and_allows_missing_value", + "eval.tests.test_entrypoint.test_help_exit_zero_on_stdout_empty", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv0]", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv1]", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv2]", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv3]", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv4]", + "eval.tests.test_entrypoint.test_help_has_priority_over_argument_errors[argv5]", + "eval.tests.test_entrypoint.test_no_args_required_error", + "eval.tests.test_entrypoint.test_valid_incantation_exit_zero_silent", + "eval.tests.test_extended_behavior.test_duplicate_named_detected_across_equate_forms", + "eval.tests.test_extended_behavior.test_flag_appearing_before_positional_accepted", + "eval.tests.test_extended_behavior.test_full_invocation_multiple_spellings", + "eval.tests.test_extended_behavior.test_named_real_negative_values_short_and_long", + "eval.tests.test_extended_behavior.test_optional_short_string_dash_value_space_equated", + "eval.tests.test_extended_behavior.test_optional_string_dash_prefixed_value_equals_form", + "eval.tests.test_extended_behavior.test_positional_0_negative_in_long_long_range", + "eval.tests.test_extended_behavior.test_positional_0_signed_spellings_accepted[+5]", + "eval.tests.test_extended_behavior.test_positional_0_signed_spellings_accepted[-0]", + "eval.tests.test_flag_and_optional.test_duplicate_flag_rejected", + "eval.tests.test_flag_and_optional.test_flag_accepted_via_short_and_long[--flag]", + "eval.tests.test_flag_and_optional.test_flag_accepted_via_short_and_long[-f]", + "eval.tests.test_flag_and_optional.test_flag_alias_short_and_long_together", + "eval.tests.test_flag_and_optional.test_flag_combined_with_named_in_separate_forms", + "eval.tests.test_flag_and_optional.test_flag_with_value_rejected[--flag=0---flag]", + "eval.tests.test_flag_and_optional.test_flag_with_value_rejected[--flag=1---flag]", + "eval.tests.test_flag_and_optional.test_flag_with_value_rejected[--flag=true---flag]", + "eval.tests.test_flag_and_optional.test_flag_with_value_rejected[-f=1--f]", + "eval.tests.test_flag_and_optional.test_optional_string_free_text[-dash]", + "eval.tests.test_flag_and_optional.test_optional_string_free_text[]", + "eval.tests.test_flag_and_optional.test_optional_string_free_text[a=1]", + "eval.tests.test_flag_and_optional.test_optional_string_free_text[hello world]", + "eval.tests.test_flag_and_optional.test_optional_string_free_text[with spaces here]", + "eval.tests.test_flag_and_optional.test_optional_string_free_value_with_space", + "eval.tests.test_flag_and_optional.test_optional_string_omitted_is_default", + "eval.tests.test_flag_and_optional.test_optional_string_short_and_long_accepted", + "eval.tests.test_flag_and_optional.test_unknown_short_flag_rejected", + "eval.tests.test_help.test_help_and_h_are_identical", + "eval.tests.test_help.test_help_default_value_render", + "eval.tests.test_help.test_help_emits_program_description", + "eval.tests.test_help.test_help_flag_row_renders", + "eval.tests.test_help.test_help_long_flag_without_short_concise", + "eval.tests.test_help.test_help_named_short_and_long_concatenated", + "eval.tests.test_help.test_help_positional_required_vs_optional_brackets", + "eval.tests.test_help.test_help_renders_golden", + "eval.tests.test_help.test_help_reports_real_number_type_label", + "eval.tests.test_help.test_help_section_order", + "eval.tests.test_help.test_help_usage_line_matches_exact", + "eval.tests.test_help.test_help_usage_section_follows_heading", + "eval.tests.test_help.test_help_via_long_and_short_exits_zero[--help]", + "eval.tests.test_help.test_help_via_long_and_short_exits_zero[-h]", + "eval.tests.test_help.test_named_i_help_row_renders", + "eval.tests.test_named_int.test_duplicate_i_occurrences_rejected", + "eval.tests.test_named_int.test_named_i_int_range_boundary_max", + "eval.tests.test_named_int.test_named_i_int_range_boundary_min", + "eval.tests.test_named_int.test_named_i_integer_accepted[+5]", + "eval.tests.test_named_int.test_named_i_integer_accepted[-12]", + "eval.tests.test_named_int.test_named_i_integer_accepted[-2147483648]", + "eval.tests.test_named_int.test_named_i_integer_accepted[-7]", + "eval.tests.test_named_int.test_named_i_integer_accepted[0]", + "eval.tests.test_named_int.test_named_i_integer_accepted[2147483647]", + "eval.tests.test_named_int.test_named_i_integer_accepted[5]", + "eval.tests.test_named_int.test_named_i_integer_accepted[999]", + "eval.tests.test_named_int.test_named_i_long_only_form_rejected", + "eval.tests.test_named_int.test_named_i_not_an_integer[-]", + "eval.tests.test_named_int.test_named_i_not_an_integer[12 34]", + "eval.tests.test_named_int.test_named_i_not_an_integer[123abc]", + "eval.tests.test_named_int.test_named_i_not_an_integer[1e3]", + "eval.tests.test_named_int.test_named_i_not_an_integer[3.5]", + "eval.tests.test_named_int.test_named_i_not_an_integer[abc]", + "eval.tests.test_named_int.test_named_i_not_an_integer[x]", + "eval.tests.test_named_int.test_named_i_out_of_range_longlong[-999999999999999999999999]", + "eval.tests.test_named_int.test_named_i_out_of_range_longlong[999999999999999999999999]", + "eval.tests.test_named_int.test_named_i_required_even_with_positional", + "eval.tests.test_named_int.test_named_i_required_when_flag_value_attachment_invalid", + "eval.tests.test_named_int.test_named_i_space_separated_value", + "eval.tests.test_named_int.test_named_value_missing_flaglike_requires_value", + "eval.tests.test_real.test_def_r_default_not_required", + "eval.tests.test_real.test_def_r_double_max_boundary_accepted", + "eval.tests.test_real.test_def_r_nan_inf_out_of_range_exact[-inf]", + "eval.tests.test_real.test_def_r_nan_inf_out_of_range_exact[-nan]", + "eval.tests.test_real.test_def_r_nan_inf_out_of_range_exact[inf]", + "eval.tests.test_real.test_def_r_nan_inf_out_of_range_exact[nan]", + "eval.tests.test_real.test_def_r_not_a_real_number[--]", + "eval.tests.test_real.test_def_r_not_a_real_number[1,5]", + "eval.tests.test_real.test_def_r_not_a_real_number[1-2]", + "eval.tests.test_real.test_def_r_not_a_real_number[1.5.5]", + "eval.tests.test_real.test_def_r_not_a_real_number[3x]", + "eval.tests.test_real.test_def_r_not_a_real_number[abc]", + "eval.tests.test_real.test_def_r_not_a_real_number[x3]", + "eval.tests.test_real.test_def_r_out_of_double_range[-1.8e308]", + "eval.tests.test_real.test_def_r_out_of_double_range[1.8e308]", + "eval.tests.test_real.test_def_r_out_of_double_range[1e309]", + "eval.tests.test_real.test_def_r_out_of_range_reports_argument_name", + "eval.tests.test_real.test_def_r_real_accepted[-0.0]", + "eval.tests.test_real.test_def_r_real_accepted[-1.5]", + "eval.tests.test_real.test_def_r_real_accepted[-2.5e-3]", + "eval.tests.test_real.test_def_r_real_accepted[.5]", + "eval.tests.test_real.test_def_r_real_accepted[0]", + "eval.tests.test_real.test_def_r_real_accepted[1E5]", + "eval.tests.test_real.test_def_r_real_accepted[1e-300]", + "eval.tests.test_real.test_def_r_real_accepted[1e308]", + "eval.tests.test_real.test_def_r_real_accepted[2.5]", + "eval.tests.test_real.test_def_r_real_accepted[2.5e2]", + "eval.tests.test_real.test_def_r_real_accepted[3.14159]", + "eval.tests.test_real.test_def_r_real_accepted[42]", + "eval.tests.test_real.test_def_r_real_accepted[5.]", + "eval.tests.test_real.test_def_r_short_name_r_equals_long", + "eval.tests.test_real.test_def_r_space_separated_value", + "eval.tests.test_required_and_positional.test_extra_third_positional_rejected", + "eval.tests.test_required_and_positional.test_negative_positional_reports_must_be_positive", + "eval.tests.test_required_and_positional.test_option_positional_1_int_boundaries_accepted", + "eval.tests.test_required_and_positional.test_optional_positional_1_malformed_rejected", + "eval.tests.test_required_and_positional.test_optional_positional_1_omitted_valid", + "eval.tests.test_required_and_positional.test_optional_positional_1_out_of_range_rejected", + "eval.tests.test_required_and_positional.test_optional_positional_1_positive_accepted", + "eval.tests.test_required_and_positional.test_optional_positional_1_signed_int_negative_accepted", + "eval.tests.test_required_and_positional.test_positional_0_not_an_integer[12x]", + "eval.tests.test_required_and_positional.test_positional_0_not_an_integer[3.5]", + "eval.tests.test_required_and_positional.test_positional_0_not_an_integer[abc]", + "eval.tests.test_required_and_positional.test_positional_0_not_an_integer[x10]", + "eval.tests.test_required_and_positional.test_positional_0_out_of_range[4294967296-argument <0> value 4294967296 out of range [0, 4294967295]]", + "eval.tests.test_required_and_positional.test_positional_0_out_of_range[99999999999999999999-parameter <0> value 99999999999999999999 out of range]", + "eval.tests.test_required_and_positional.test_positional_0_valid_bounds[0]", + "eval.tests.test_required_and_positional.test_positional_0_valid_bounds[1]", + "eval.tests.test_required_and_positional.test_positional_0_valid_bounds[4294967295]", + "eval.tests.test_required_and_positional.test_positional_token_after_double_dash_consumed_as_positional", + "eval.tests.test_required_and_positional.test_required_named_i_missing_errors[argv0]", + "eval.tests.test_required_and_positional.test_required_named_i_missing_errors[argv1]", + "eval.tests.test_required_and_positional.test_required_positional_0_missing_errors[argv0]", + "eval.tests.test_required_and_positional.test_required_positional_0_missing_errors[argv1]", + "eval.tests.test_required_and_positional.test_required_positional_0_missing_errors[argv2]", + "eval.tests.test_syntax_expansion.test_combined_flags_only", + "eval.tests.test_syntax_expansion.test_flag_aliases_across_forms", + "eval.tests.test_syntax_expansion.test_flag_short_and_long_aliases_not_duplicates", + "eval.tests.test_syntax_expansion.test_flag_value_glued_short_rejected", + "eval.tests.test_syntax_expansion.test_short_flag_value_concatenated_equated", + "eval.tests.test_syntax_expansion.test_short_flag_value_concatenated_rejected_for_unknown", + "eval.tests.test_syntax_expansion.test_short_string_value_concatenated_equated", + "eval.tests.test_syntax_expansion.test_short_value_concatenation_equals_equals_form", + "eval.tests.test_syntax_expansion.test_single_hyphen_group_with_long_flag_present" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_all_combinations.test_boolean_flag_accepted[--flag]", + "eval.tests.test_all_combinations.test_boolean_flag_accepted[-f]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args0-Error: required argument <0> not provided\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args1-Error: required argument -i not provided\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args2-Error: invalid argument --undefined\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args3-Error: parameter -i value abc is not an integer\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args4-Error: parameter --def-r value abc is not a real number\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args5-Error: argument <0> value -1 must be positive\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args6-Error: invalid positional argument 2\\n]", + "eval.tests.test_all_combinations.test_handled_failure_diagnostic[args7-Error: argument -i must have value\\n]", + "eval.tests.test_all_combinations.test_help_matches_usage_golden[--help]", + "eval.tests.test_all_combinations.test_help_matches_usage_golden[-h]", + "eval.tests.test_all_combinations.test_valid_parse_succeeds_silently[0 -i=0]", + "eval.tests.test_all_combinations.test_valid_parse_succeeds_silently[0 1 -i 0 --def-r 0.0 --opt-s string]", + "eval.tests.test_all_combinations.test_valid_parse_succeeds_silently[0 1 -i=0 --def-r=0.0 --opt-s=string]" + ] + } + }, + "commit": "7d000fd65375503bc7c8bb2add9c97b0f0110613", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.1586639808139894, + "eval_clean_hashes": [ + "d3e9f481987a57735623499ee79f362fa6bdf21acbd58058d02ad9a02dda60d7" + ], + "input_record": { + "commit": "7d000fd65375503bc7c8bb2add9c97b0f0110613", + "difficulty": "easy", + "difficulty_code_lines": 1441, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 1441, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.1586639808139894, + "difficulty_test_code_lines": 1577, + "full_name": "kongaskristjan/fire-hpp", + "input_joern_zip": "cpp_joern/kongaskristjan__fire-hpp.zip", + "joern_status": true, + "joern_time": 39.4950320799835, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 545, + "similarity": 0.47748470306396484 + }, + { + "pb_fullname": "duckdb/duckdb", + "rank": 410, + "similarity": 0.4630683362483978 + }, + { + "pb_fullname": "facebookresearch/fastText", + "rank": 546, + "similarity": 0.4544226825237274 + }, + { + "pb_fullname": "ArthurSonzogni/json-tui", + "rank": 149, + "similarity": 0.5112231969833374 + }, + { + "pb_fullname": "ninja-build/ninja", + "rank": 7, + "similarity": 0.5788892507553101 + }, + { + "pb_fullname": "tstack/lnav", + "rank": 326, + "similarity": 0.4627346396446228 + }, + { + "pb_fullname": "NikolaDucak/caps-log", + "rank": 160, + "similarity": 0.4475822150707245 + }, + { + "pb_fullname": "HaliteChallenge/Halite", + "rank": 377, + "similarity": 0.45878052711486816 + } + ], + "repo_path": "cpp/kongaskristjan__fire-hpp", + "source": "commit:7d000fd65375503bc7c8bb2add9c97b0f0110613", + "status": "done", + "url": "https://github.com/kongaskristjan/fire-hpp" + }, + "instance_id": "kongaskristjan__fire-hpp.7d000fd", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 3, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 2, + "branch_name": "generated_upstream", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "tests", + "termination_reason": "module_coverage_threshold_reached" + } + ], + "repository": "kongaskristjan/fire-hpp" +} diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/test.sh b/kongaskristjan--fire-hpp.7d000fd/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kongaskristjan--fire-hpp.7d000fd/tests/workspace.tar.gz b/kongaskristjan--fire-hpp.7d000fd/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..94b50f898ab748d56878bb88850ccc9756b2c74c --- /dev/null +++ b/kongaskristjan--fire-hpp.7d000fd/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e312194e56a3c45fc74144bda8ef8c6b002bb52069176769a0987eb48bc7a5a +size 24104 diff --git a/kovacsv--occt-import-js.41e4708/environment/Dockerfile b/kovacsv--occt-import-js.41e4708/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kovacsv--occt-import-js.41e4708/environment/docker-compose.yaml b/kovacsv--occt-import-js.41e4708/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kovacsv--occt-import-js.41e4708/environment/download.sh b/kovacsv--occt-import-js.41e4708/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..d702601b6401b4be6b14aebe67eee0a9f34dc338 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/download.sh @@ -0,0 +1,70 @@ +#!/usr/bin/env bash +# +# download.sh - prefetch the OCCT dependency for the offline native build. +# +# The occt-import-js repository imports STEP/IGES/BREP files through the Open +# CASCADE (OCCT) library. Its CMake build compiles the entire bundled OCCT +# source tree (occt/ submodule) inline, which takes far too long for the +# offline build stage and previously timed out. This download step instead +# installs the prebuilt OCCT 7.5.1 libraries from the Ubuntu 22.04 repositories +# (libocct-*-dev). build.sh then compiles only the small set of project source +# files of the selected OcctImportJSExample target and links them against these +# prebuilt OCCT libraries, keeping the offline build short. +# +# This file is sourced via `source /source_ro/download.sh` during the network +# download validation stage, where the repository is mounted READ-ONLY. It must +# therefore: +# - write only to system locations (apt) and /tmp, never into the current +# working directory; +# - be a completely standalone script that reads no repository file; +# - perform no compile, link, test or packaging step (apt-get installation of +# system packages is a dependency-setup step and is allowed here); +# - be idempotent, and never `exit` in normal control flow (it is sourced, so +# failures use `return` when sourced). + +set -u + +PB_OCCT_DEV_PACKAGES="libocct-foundation-dev libocct-modeling-data-dev libocct-modeling-algorithms-dev libocct-data-exchange-dev libocct-ocaf-dev libocct-visualization-dev" + +pb_fail () { + echo "download.sh: ERROR: $*" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# Refresh the apt package index (required on a freshly provisioned image). +echo "download.sh: running apt-get update." +apt-get update >/tmp/pb_download_apt_update.log 2>/tmp/pb_download_apt_update.err +if [ $? -eq 0 ]; then + echo "download.sh: apt-get update succeeded." +else + pb_fail "apt-get update failed (see /tmp/pb_download_apt_update.err)." +fi + +# Install the prebuilt OCCT development packages (headers + runtime libraries). +# This is idempotent: already-present packages are skipped by apt. +echo "download.sh: installing OCCT dev packages." +apt-get install -y --no-install-recommends $PB_OCCT_DEV_PACKAGES >/tmp/pb_download_apt_install.log 2>/tmp/pb_download_apt_install.err +if [ $? -eq 0 ]; then + echo "download.sh: installed OCCT development packages:" + for pkg in $PB_OCCT_DEV_PACKAGES; do + echo "download.sh: $pkg" + done +else + pb_fail "apt-get install of OCCT packages failed (see /tmp/pb_download_apt_install.err)." +fi + +# Verify that the OCCT headers and core library that build.sh compiles against +# are actually present after installation. +if [ -f /usr/include/opencascade/UnitsMethods.hxx ] && \ + [ -f /usr/include/opencascade/Poly_Triangulation.hxx ] && \ + [ -f /usr/lib/x86_64-linux-gnu/libTKernel.so ]; then + echo "download.sh: OCCT headers and libraries verified present." +else + pb_fail "OCCT headers or libraries were not found after install." +fi + +echo "download.sh: OCCT dependency ready." diff --git a/kovacsv--occt-import-js.41e4708/environment/executable b/kovacsv--occt-import-js.41e4708/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..64110c99cdad30abbacd45f650d667ffa35b1307 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd2990318b384d3edc31c0050d23df9107dee2958d8822fd5c436ff7544f2086 +size 3130696 diff --git a/kovacsv--occt-import-js.41e4708/environment/harbor_configure_apt_mirror.sh b/kovacsv--occt-import-js.41e4708/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kovacsv--occt-import-js.41e4708/environment/harbor_prepare_download_env.sh b/kovacsv--occt-import-js.41e4708/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kovacsv--occt-import-js.41e4708/environment/workspace.tar.gz b/kovacsv--occt-import-js.41e4708/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..26e81190154663417ebdf7a91573b99ccb8437b3 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9ededaa0ba5330521af2f88ccb3fe49cc3a3c859c172c6b1276040c05ecaf7c +size 36866 diff --git a/kovacsv--occt-import-js.41e4708/instruction.md b/kovacsv--occt-import-js.41e4708/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kovacsv--occt-import-js.41e4708/solution/solve.sh b/kovacsv--occt-import-js.41e4708/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kovacsv--occt-import-js.41e4708/task.toml b/kovacsv--occt-import-js.41e4708/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..519d8c1f78548680c1f5902e04956a030cb3329e --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kovacsv--occt-import-js.41e4708" +description = "Synthetic ProgramGym cleanroom reconstruction task for kovacsv/occt-import-js" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kovacsv__occt-import-js.41e4708" +repository = "kovacsv/occt-import-js" +commit = "41e470890ae0f9dc69ac50ffd5fc73e03576f4eb" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.12515582958053 +test_branches = 3 +test_count = 493 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kovacsv--occt-import-js.41e4708/tests/Dockerfile b/kovacsv--occt-import-js.41e4708/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_02.tar.gz b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6cb226ff7e7abd575db2e1bc89e2922843016183 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:094a91c20269325d7e46f50768da169e1c9ae780eabfce6e5ed9abf473c5ba6b +size 88043 diff --git a/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_03.tar.gz b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1296ff913ca0f1bc51d009a65a7f3eb2b27ca6f4 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c329ae8e81091a403c88c7ca7b795e94e85a2b3905f2c5b2aad6fc90b0209df +size 394102 diff --git a/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_04.tar.gz b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..bc800bd3fc8f6b6b9d1217b4026b1485976d4ecd --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c4f83e259231cea95445d54cbb279cec8f9ce2d83ddf8cabdac0b0fe3091823 +size 140788 diff --git a/kovacsv--occt-import-js.41e4708/tests/docker-compose.yaml b/kovacsv--occt-import-js.41e4708/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kovacsv--occt-import-js.41e4708/tests/download.sh b/kovacsv--occt-import-js.41e4708/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..d702601b6401b4be6b14aebe67eee0a9f34dc338 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/download.sh @@ -0,0 +1,70 @@ +#!/usr/bin/env bash +# +# download.sh - prefetch the OCCT dependency for the offline native build. +# +# The occt-import-js repository imports STEP/IGES/BREP files through the Open +# CASCADE (OCCT) library. Its CMake build compiles the entire bundled OCCT +# source tree (occt/ submodule) inline, which takes far too long for the +# offline build stage and previously timed out. This download step instead +# installs the prebuilt OCCT 7.5.1 libraries from the Ubuntu 22.04 repositories +# (libocct-*-dev). build.sh then compiles only the small set of project source +# files of the selected OcctImportJSExample target and links them against these +# prebuilt OCCT libraries, keeping the offline build short. +# +# This file is sourced via `source /source_ro/download.sh` during the network +# download validation stage, where the repository is mounted READ-ONLY. It must +# therefore: +# - write only to system locations (apt) and /tmp, never into the current +# working directory; +# - be a completely standalone script that reads no repository file; +# - perform no compile, link, test or packaging step (apt-get installation of +# system packages is a dependency-setup step and is allowed here); +# - be idempotent, and never `exit` in normal control flow (it is sourced, so +# failures use `return` when sourced). + +set -u + +PB_OCCT_DEV_PACKAGES="libocct-foundation-dev libocct-modeling-data-dev libocct-modeling-algorithms-dev libocct-data-exchange-dev libocct-ocaf-dev libocct-visualization-dev" + +pb_fail () { + echo "download.sh: ERROR: $*" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# Refresh the apt package index (required on a freshly provisioned image). +echo "download.sh: running apt-get update." +apt-get update >/tmp/pb_download_apt_update.log 2>/tmp/pb_download_apt_update.err +if [ $? -eq 0 ]; then + echo "download.sh: apt-get update succeeded." +else + pb_fail "apt-get update failed (see /tmp/pb_download_apt_update.err)." +fi + +# Install the prebuilt OCCT development packages (headers + runtime libraries). +# This is idempotent: already-present packages are skipped by apt. +echo "download.sh: installing OCCT dev packages." +apt-get install -y --no-install-recommends $PB_OCCT_DEV_PACKAGES >/tmp/pb_download_apt_install.log 2>/tmp/pb_download_apt_install.err +if [ $? -eq 0 ]; then + echo "download.sh: installed OCCT development packages:" + for pkg in $PB_OCCT_DEV_PACKAGES; do + echo "download.sh: $pkg" + done +else + pb_fail "apt-get install of OCCT packages failed (see /tmp/pb_download_apt_install.err)." +fi + +# Verify that the OCCT headers and core library that build.sh compiles against +# are actually present after installation. +if [ -f /usr/include/opencascade/UnitsMethods.hxx ] && \ + [ -f /usr/include/opencascade/Poly_Triangulation.hxx ] && \ + [ -f /usr/lib/x86_64-linux-gnu/libTKernel.so ]; then + echo "download.sh: OCCT headers and libraries verified present." +else + pb_fail "OCCT headers or libraries were not found after install." +fi + +echo "download.sh: OCCT dependency ready." diff --git a/kovacsv--occt-import-js.41e4708/tests/executable b/kovacsv--occt-import-js.41e4708/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..64110c99cdad30abbacd45f650d667ffa35b1307 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd2990318b384d3edc31c0050d23df9107dee2958d8822fd5c436ff7544f2086 +size 3130696 diff --git a/kovacsv--occt-import-js.41e4708/tests/harbor_configure_apt_mirror.sh b/kovacsv--occt-import-js.41e4708/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kovacsv--occt-import-js.41e4708/tests/harbor_prepare_download_env.sh b/kovacsv--occt-import-js.41e4708/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kovacsv--occt-import-js.41e4708/tests/programgym_evaluator.py b/kovacsv--occt-import-js.41e4708/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kovacsv--occt-import-js.41e4708/tests/programgym_task.json b/kovacsv--occt-import-js.41e4708/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..cf3eb7bb449c18c82837d7bf6b3d42711b23f0e1 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/programgym_task.json @@ -0,0 +1,772 @@ +{ + "branches": { + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_golden_outputs.test_cube_obj_matches_baseline", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_golden_outputs.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_outputs.test_iges_stdout_and_obj_match_baseline", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_golden_outputs.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_outputs.test_rounded_cube_obj_matches_baseline", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_golden_outputs.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_outputs.test_rounded_cube_stdout_matches_baseline", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_golden_outputs.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_mesh_walk_equivalence.test_brep_assembly_vertices_are_shared_across_faces", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_mesh_walk_equivalence.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_mesh_walk_equivalence.test_curved_shape_emits_more_vertices_than_unique_corners", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_mesh_walk_equivalence.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_mesh_walk_equivalence.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_brep_import.test_brep_and_step_share_the_same_physical_extent", + "eval.tests.test_brep_import.test_brep_assembly_manifest", + "eval.tests.test_brep_import.test_brep_brp_extension_alias", + "eval.tests.test_brep_import.test_brep_covers_standalone_and_solid_faces", + "eval.tests.test_brep_import.test_brep_garbage_content_fails", + "eval.tests.test_brep_import.test_brep_meshes_have_empty_names", + "eval.tests.test_brep_import.test_brep_obj_matches_dump", + "eval.tests.test_geometry_semantics.test_all_walked_coordinates_are_finite[assembly-brep]", + "eval.tests.test_geometry_semantics.test_all_walked_coordinates_are_finite[assembly-dm1]", + "eval.tests.test_geometry_semantics.test_all_walked_coordinates_are_finite[cube]", + "eval.tests.test_geometry_semantics.test_all_walked_coordinates_are_finite[iges]", + "eval.tests.test_geometry_semantics.test_all_walked_coordinates_are_finite[rounded]", + "eval.tests.test_geometry_semantics.test_assembly_dump_contains_non_mesh_intermediate_nodes", + "eval.tests.test_geometry_semantics.test_assembly_obj_groups_are_numbered_contiguously", + "eval.tests.test_geometry_semantics.test_every_emitted_normal_is_unit_length[assembly-brep]", + "eval.tests.test_geometry_semantics.test_every_emitted_normal_is_unit_length[assembly-dm1]", + "eval.tests.test_geometry_semantics.test_every_emitted_normal_is_unit_length[cube]", + "eval.tests.test_geometry_semantics.test_every_emitted_normal_is_unit_length[iges]", + "eval.tests.test_geometry_semantics.test_every_emitted_normal_is_unit_length[rounded]", + "eval.tests.test_geometry_semantics.test_every_triangle_index_references_an_emitted_node[assembly-brep]", + "eval.tests.test_geometry_semantics.test_every_triangle_index_references_an_emitted_node[assembly-dm1]", + "eval.tests.test_geometry_semantics.test_every_triangle_index_references_an_emitted_node[cube]", + "eval.tests.test_geometry_semantics.test_every_triangle_index_references_an_emitted_node[iges]", + "eval.tests.test_geometry_semantics.test_every_triangle_index_references_an_emitted_node[rounded]", + "eval.tests.test_geometry_semantics.test_exported_obj_has_no_degenerate_or_zero_area_face[assembly-brep]", + "eval.tests.test_geometry_semantics.test_exported_obj_has_no_degenerate_or_zero_area_face[assembly-dm1]", + "eval.tests.test_geometry_semantics.test_exported_obj_has_no_degenerate_or_zero_area_face[cube]", + "eval.tests.test_geometry_semantics.test_exported_obj_has_no_degenerate_or_zero_area_face[iges]", + "eval.tests.test_geometry_semantics.test_exported_obj_has_no_degenerate_or_zero_area_face[rounded]", + "eval.tests.test_geometry_semantics.test_flat_and_curved_cube_triangulation_vertices_are_distinct", + "eval.tests.test_golden_outputs.test_cube_obj_matches_baseline", + "eval.tests.test_golden_outputs.test_iges_stdout_and_obj_match_baseline", + "eval.tests.test_golden_outputs.test_rounded_cube_obj_matches_baseline", + "eval.tests.test_golden_outputs.test_rounded_cube_stdout_matches_baseline", + "eval.tests.test_iges_import.test_iges_cube_mesh_manifest", + "eval.tests.test_iges_import.test_iges_cube_mesh_name_solid1", + "eval.tests.test_iges_import.test_iges_garbage_content_fails", + "eval.tests.test_iges_import.test_iges_igs_extension_alias", + "eval.tests.test_iges_import.test_iges_normals_are_unit_length", + "eval.tests.test_iges_import.test_iges_obj_matches_dump", + "eval.tests.test_iges_import.test_iges_triangle_indices_valid", + "eval.tests.test_import_errors.test_case_insensitive_extension_accepted", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.brep]", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.brp]", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.iges]", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.igs]", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.step]", + "eval.tests.test_import_errors.test_each_supported_extension_only_when_payload_is_valid[.stp]", + "eval.tests.test_import_errors.test_garbage_brep_content_import_fails", + "eval.tests.test_import_errors.test_import_failure_does_not_leave_partial_obj", + "eval.tests.test_import_errors.test_invalid_step_content_import_fails[empty]", + "eval.tests.test_import_errors.test_invalid_step_content_import_fails[garbage]", + "eval.tests.test_import_errors.test_invalid_step_content_import_fails[whitespace]", + "eval.tests.test_import_errors.test_invocation_without_supported_file_is_rejected[no-args]", + "eval.tests.test_import_errors.test_invocation_without_supported_file_is_rejected[no-extension]", + "eval.tests.test_import_errors.test_missing_file_returns_failure[brep]", + "eval.tests.test_import_errors.test_missing_file_returns_failure[igs]", + "eval.tests.test_import_errors.test_missing_file_returns_failure[step]", + "eval.tests.test_import_errors.test_missing_file_returns_failure[stp]", + "eval.tests.test_import_errors.test_truncated_step_content_import_fails", + "eval.tests.test_import_errors.test_unreadable_file_import_fails", + "eval.tests.test_import_errors.test_unsupported_extension_rejected[obj]", + "eval.tests.test_import_errors.test_unsupported_extension_rejected[stl]", + "eval.tests.test_import_errors.test_unsupported_extension_rejected[txt]", + "eval.tests.test_import_errors.test_unsupported_extension_rejected[xyz]", + "eval.tests.test_mesh_walk_equivalence.test_brep_assembly_vertices_are_shared_across_faces", + "eval.tests.test_mesh_walk_equivalence.test_curved_shape_emits_more_vertices_than_unique_corners", + "eval.tests.test_mesh_walk_equivalence.test_every_emitted_vertex_is_unit_normalized[assembly-brep]", + "eval.tests.test_mesh_walk_equivalence.test_every_emitted_vertex_is_unit_normalized[assembly-dm1]", + "eval.tests.test_mesh_walk_equivalence.test_every_emitted_vertex_is_unit_normalized[cube]", + "eval.tests.test_mesh_walk_equivalence.test_every_emitted_vertex_is_unit_normalized[iges]", + "eval.tests.test_mesh_walk_equivalence.test_every_emitted_vertex_is_unit_normalized[rounded]", + "eval.tests.test_mesh_walk_equivalence.test_flat_cube_shares_vertices_within_planar_faces", + "eval.tests.test_mesh_walk_equivalence.test_obj_emits_exactly_one_normal_per_vertex[assembly-brep]", + "eval.tests.test_mesh_walk_equivalence.test_obj_emits_exactly_one_normal_per_vertex[assembly-dm1]", + "eval.tests.test_mesh_walk_equivalence.test_obj_emits_exactly_one_normal_per_vertex[cube]", + "eval.tests.test_mesh_walk_equivalence.test_obj_emits_exactly_one_normal_per_vertex[iges]", + "eval.tests.test_mesh_walk_equivalence.test_obj_emits_exactly_one_normal_per_vertex[rounded]", + "eval.tests.test_mesh_walk_equivalence.test_obj_normal_sequence_equals_dump_walk[assembly-brep]", + "eval.tests.test_mesh_walk_equivalence.test_obj_normal_sequence_equals_dump_walk[assembly-dm1]", + "eval.tests.test_mesh_walk_equivalence.test_obj_normal_sequence_equals_dump_walk[cube]", + "eval.tests.test_mesh_walk_equivalence.test_obj_normal_sequence_equals_dump_walk[iges]", + "eval.tests.test_mesh_walk_equivalence.test_obj_normal_sequence_equals_dump_walk[rounded]", + "eval.tests.test_mesh_walk_equivalence.test_obj_vertex_sequence_equals_dump_walk[assembly-brep]", + "eval.tests.test_mesh_walk_equivalence.test_obj_vertex_sequence_equals_dump_walk[assembly-dm1]", + "eval.tests.test_mesh_walk_equivalence.test_obj_vertex_sequence_equals_dump_walk[cube]", + "eval.tests.test_mesh_walk_equivalence.test_obj_vertex_sequence_equals_dump_walk[iges]", + "eval.tests.test_mesh_walk_equivalence.test_obj_vertex_sequence_equals_dump_walk[rounded]", + "eval.tests.test_node_mesh_model.test_ascii_geometry_printed_before_dump", + "eval.tests.test_node_mesh_model.test_brep_flattens_assembly_to_single_anonymous_node", + "eval.tests.test_node_mesh_model.test_dump_emits_one_node_line_per_mesh_node", + "eval.tests.test_node_mesh_model.test_node_dump_mesh_count_matches_geometry_mesh_count", + "eval.tests.test_node_mesh_model.test_root_node_is_anonymous", + "eval.tests.test_node_mesh_model.test_single_mesh_node_has_expected_child_and_mesh[cube]", + "eval.tests.test_node_mesh_model.test_single_mesh_node_has_expected_child_and_mesh[iges-solid1]", + "eval.tests.test_node_mesh_model.test_single_mesh_node_has_expected_child_and_mesh[rounded-body]", + "eval.tests.test_node_mesh_model.test_step_assembly_preserves_named_node_hierarchy", + "eval.tests.test_output_structure.test_each_mesh_end_precedes_next_mesh_start[assembly]", + "eval.tests.test_output_structure.test_each_mesh_end_precedes_next_mesh_start[cube]", + "eval.tests.test_output_structure.test_each_mesh_end_precedes_next_mesh_start[rounded]", + "eval.tests.test_output_structure.test_geometry_block_precedes_node_dump", + "eval.tests.test_output_structure.test_mesh_face_blocks_are_balanced[assembly]", + "eval.tests.test_output_structure.test_mesh_face_blocks_are_balanced[cube]", + "eval.tests.test_output_structure.test_mesh_face_blocks_are_balanced[rounded]", + "eval.tests.test_output_structure.test_no_face_start_without_face_end[assembly]", + "eval.tests.test_output_structure.test_no_face_start_without_face_end[cube]", + "eval.tests.test_output_structure.test_no_face_start_without_face_end[rounded]", + "eval.tests.test_output_structure.test_obj_faces_pair_vertex_with_normal_indices", + "eval.tests.test_output_structure.test_obj_group_count_matches_mesh_count", + "eval.tests.test_output_structure.test_obj_is_the_only_output_file_created", + "eval.tests.test_stateful_behavior.test_failed_import_preserves_prior_generated_output", + "eval.tests.test_stateful_behavior.test_repeated_valid_import_overwrites_result_obj", + "eval.tests.test_stateful_behavior.test_trailing_arguments_are_ignored", + "eval.tests.test_step_import.test_assembly_many_meshes_manifest", + "eval.tests.test_step_import.test_assembly_obj_matches_dump", + "eval.tests.test_step_import.test_colored_assembly_mesh_colors", + "eval.tests.test_step_import.test_cube_axis_aligned_normals", + "eval.tests.test_step_import.test_cube_known_vertex_and_normal_values", + "eval.tests.test_step_import.test_cube_step_mesh_manifest[Cube-10x10.stp]", + "eval.tests.test_step_import.test_cube_step_mesh_manifest[cube-fcstd.step]", + "eval.tests.test_step_import.test_cube_step_mesh_manifest[cube.stp]", + "eval.tests.test_step_import.test_cube_step_obj_payload_matches_dump[Cube-10x10.stp]", + "eval.tests.test_step_import.test_cube_step_obj_payload_matches_dump[cube-fcstd.step]", + "eval.tests.test_step_import.test_cube_step_obj_payload_matches_dump[cube.stp]", + "eval.tests.test_step_import.test_cube_step_vertex_extents", + "eval.tests.test_step_import.test_different_geometry_gives_different_triangle_counts", + "eval.tests.test_step_import.test_fcstd_cube_has_grey_color_and_name", + "eval.tests.test_step_import.test_mesh_node_dump_starts_after_geometry", + "eval.tests.test_step_import.test_negative_zero_is_rendered_but_numeric", + "eval.tests.test_step_import.test_normals_are_one_per_vertex_and_unit[Cube-10x10.stp]", + "eval.tests.test_step_import.test_normals_are_one_per_vertex_and_unit[cube-fcstd.step]", + "eval.tests.test_step_import.test_normals_are_one_per_vertex_and_unit[cube.stp]", + "eval.tests.test_step_import.test_obj_face_indices_are_1_based_and_match[Cube-10x10.stp]", + "eval.tests.test_step_import.test_obj_face_indices_are_1_based_and_match[cube-fcstd.step]", + "eval.tests.test_step_import.test_obj_face_indices_are_1_based_and_match[cube.stp]", + "eval.tests.test_step_import.test_rounded_cube_curved_vertices_are_smooth", + "eval.tests.test_step_import.test_rounded_cube_triangulation_is_refined", + "eval.tests.test_step_import.test_step_mesh_names_and_colors", + "eval.tests.test_step_import.test_triangle_indices_in_range[Cube-10x10.stp]", + "eval.tests.test_step_import.test_triangle_indices_in_range[cube-fcstd.step]", + "eval.tests.test_step_import.test_triangle_indices_in_range[cube.stp]", + "eval.tests.test_triangulation.test_curved_vertices_are_discretized", + "eval.tests.test_triangulation.test_flat_vs_curved_triangle_densities", + "eval.tests.test_triangulation.test_identical_input_is_deterministic[assembly]", + "eval.tests.test_triangulation.test_identical_input_is_deterministic[cube]", + "eval.tests.test_triangulation.test_identical_input_is_deterministic[rounded]", + "eval.tests.test_triangulation.test_obj_conserves_triangle_orientation_fields", + "eval.tests.test_triangulation.test_obj_faces_are_consistently_wound[as1_pe_203]", + "eval.tests.test_triangulation.test_obj_faces_are_consistently_wound[rounded_cube]", + "eval.tests.test_triangulation.test_rounded_cube_has_reversed_and_forward_faces", + "eval.tests.test_triangulation.test_vertices_lie_within_shape_bounds", + "eval.tests.test_units.test_cube_renders_same_vertex_lattice_across_formats[iges-cube]", + "eval.tests.test_units.test_cube_renders_same_vertex_lattice_across_formats[step-cube]", + "eval.tests.test_units.test_cube_vertex_spread_equal_across_axes", + "eval.tests.test_units.test_meter_cube_emits_exact_unit_corners", + "eval.tests.test_units.test_meter_render_unit_normalizes_all_cubes[inches]", + "eval.tests.test_units.test_meter_render_unit_normalizes_all_cubes[meters]", + "eval.tests.test_units.test_meter_render_unit_normalizes_all_cubes[millimeters]", + "eval.tests.test_units.test_unit_conversion_is_deterministic_across_runs" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_assembly_parts.test_s1c5_parts_resolve_distinct_names", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_assembly_parts.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_assembly_parts.test_s1pe_parts_resolve_solid_name", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_assembly_parts.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_units.test_unit_variants_have_identical_output", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_units.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_assembly_parts.test_empty_assemblies_emit_no_mesh_events", + "eval.tests.test_assembly_parts.test_empty_assemblies_have_root_only_node_dump", + "eval.tests.test_assembly_parts.test_empty_assemblies_import_exit_zero", + "eval.tests.test_assembly_parts.test_empty_assemblies_result_obj_is_empty", + "eval.tests.test_assembly_parts.test_s1c5_parts_resolve_distinct_names", + "eval.tests.test_assembly_parts.test_s1c5_single_solid_colour", + "eval.tests.test_assembly_parts.test_s1pe_parts_have_colours", + "eval.tests.test_assembly_parts.test_s1pe_parts_resolve_solid_name", + "eval.tests.test_brep_import.test_brep_faces_are_mesh_start_balanced", + "eval.tests.test_brep_import.test_brep_file_dispatch_loads", + "eval.tests.test_brep_import.test_brep_flat_tree_matches_golden", + "eval.tests.test_brep_import.test_brep_meshes_have_empty_names", + "eval.tests.test_brep_import.test_brep_meshes_have_no_color", + "eval.tests.test_brep_import.test_brep_obj_face_ids_are_consistent", + "eval.tests.test_brep_import.test_brep_result_obj_has_18_groups", + "eval.tests.test_brep_import.test_brep_tree_has_single_empty_root", + "eval.tests.test_brep_import.test_brep_unknown_extension_fails_before_import", + "eval.tests.test_brep_import.test_brp_extension_dispatch_equivalent", + "eval.tests.test_brep_import.test_malformed_brep_fails", + "eval.tests.test_colors.test_as1_solids_have_distinct_colors", + "eval.tests.test_colors.test_cube_mesh_has_generic_color", + "eval.tests.test_colors.test_dm1_bolts_share_orange_color", + "eval.tests.test_colors.test_dm1_l_bracket_is_red", + "eval.tests.test_colors.test_dm1_nuts_share_color", + "eval.tests.test_colors.test_iges_mesh_color_printed", + "eval.tests.test_colors.test_sg1_mesh_color_resolution", + "eval.tests.test_deep_assemblies.test_as1tu_imports_eighteen_meshes", + "eval.tests.test_deep_assemblies.test_as1tu_nested_assembly_depth", + "eval.tests.test_deep_assemblies.test_cube_fcstd_solid_named_cube", + "eval.tests.test_deep_assemblies.test_dm1oc_mesh_names", + "eval.tests.test_deep_assemblies.test_dm1oc_meshes_resolve_no_color", + "eval.tests.test_deep_assemblies.test_dm1oc_nested_assembly_structure", + "eval.tests.test_deep_assemblies.test_dm1oc_result_obj_has_seven_groups", + "eval.tests.test_deep_assemblies.test_dm1pe_assembly_mesh_colours", + "eval.tests.test_deep_assemblies.test_dm1pe_uppercase_names", + "eval.tests.test_deep_assemblies.test_io1cm_single_yellow_solid", + "eval.tests.test_deep_assemblies.test_io1tu_has_solid_and_compound_children", + "eval.tests.test_deep_assemblies.test_io1tu_single_mesh_is_solid", + "eval.tests.test_deep_assemblies.test_io1tu_solid_grey_color", + "eval.tests.test_deep_assemblies.test_s1pe_imports_with_empty_result_tree", + "eval.tests.test_deep_assemblies.test_s1pe_root_node_only", + "eval.tests.test_extension_routing.test_all_supported_extensions_produce_obj", + "eval.tests.test_extension_routing.test_brep_extension_alias_loads", + "eval.tests.test_extension_routing.test_iges_extension_alias_loads", + "eval.tests.test_extension_routing.test_no_arguments_rejected_direct", + "eval.tests.test_extension_routing.test_no_extension_rejected", + "eval.tests.test_extension_routing.test_nonexistent_step_path_fails", + "eval.tests.test_extension_routing.test_step_extension_roundcube_loads", + "eval.tests.test_extension_routing.test_step_extension_uppercase_loads", + "eval.tests.test_extension_routing.test_trailing_dot_rejected", + "eval.tests.test_extension_routing.test_unknown_extension_rejected", + "eval.tests.test_iges_banner.test_brep_import_has_no_entities_banner", + "eval.tests.test_iges_banner.test_iges_banner_and_mesh_are_present", + "eval.tests.test_iges_banner.test_iges_banner_precedes_node_dump", + "eval.tests.test_iges_banner.test_iges_banner_reports_entities", + "eval.tests.test_iges_banner.test_step_import_has_no_entities_banner", + "eval.tests.test_import_failure.test_empty_stp_is_import_failed_not_file_not_found", + "eval.tests.test_import_failure.test_malformed_iges_alias_fails", + "eval.tests.test_import_failure.test_malformed_iges_import_fails", + "eval.tests.test_import_failure.test_malformed_step_extension_alias_fails", + "eval.tests.test_import_failure.test_malformed_step_import_fails", + "eval.tests.test_import_failure.test_truncated_step_header_fails", + "eval.tests.test_load_success.test_every_mesh_start_has_matching_mesh_end", + "eval.tests.test_load_success.test_iges_single_shape_loads_successfully", + "eval.tests.test_load_success.test_multi_shape_import_enumerates_all_meshes", + "eval.tests.test_load_success.test_result_obj_contains_group_per_mesh", + "eval.tests.test_load_success.test_result_obj_is_generated_on_success", + "eval.tests.test_load_success.test_root_node_is_always_emitted", + "eval.tests.test_load_success.test_step_single_shape_loads_successfully", + "eval.tests.test_naming.test_assembly_names_resolve", + "eval.tests.test_naming.test_iges_node_name", + "eval.tests.test_naming.test_mesh_name_matches_node_name", + "eval.tests.test_naming.test_multiword_node_names", + "eval.tests.test_naming.test_shared_leaf_names_preserved", + "eval.tests.test_naming.test_step_node_name_from_xcaf", + "eval.tests.test_product_structure.test_assembly_node_is_not_a_mesh_node", + "eval.tests.test_product_structure.test_deep_assembly_children_are_assemblies", + "eval.tests.test_product_structure.test_leaf_nodes_own_exactly_one_mesh_each", + "eval.tests.test_product_structure.test_mesh_node_count_matches_mesh_start_count", + "eval.tests.test_product_structure.test_nested_assembly_mesh_distribution", + "eval.tests.test_product_structure.test_nested_assembly_structure", + "eval.tests.test_product_structure.test_root_node_has_no_child_name", + "eval.tests.test_product_structure.test_single_shape_is_a_leaf_mesh_node", + "eval.tests.test_s1tu_sheets.test_each_sheet_node_is_named_master", + "eval.tests.test_s1tu_sheets.test_sheet_part_colour_resolution", + "eval.tests.test_s1tu_sheets.test_sheet_part_dumps_match_goldens", + "eval.tests.test_s1tu_sheets.test_sheet_part_face_and_triangle_data", + "eval.tests.test_s1tu_sheets.test_sheet_parts_have_solids_only_one_surface_mesh", + "eval.tests.test_s1tu_sheets.test_sheet_parts_load_successfully", + "eval.tests.test_surface_imports.test_conical_dump_matches_golden", + "eval.tests.test_surface_imports.test_conical_has_vertices_and_triangles", + "eval.tests.test_surface_imports.test_conical_mesh_grey_color", + "eval.tests.test_surface_imports.test_conical_node_name_is_unsaved", + "eval.tests.test_surface_imports.test_conical_single_mesh_balanced", + "eval.tests.test_surface_imports.test_rounded_cube_body_name", + "eval.tests.test_surface_imports.test_rounded_cube_dump_matches_golden", + "eval.tests.test_surface_imports.test_rounded_cube_light_grey_color", + "eval.tests.test_surface_imports.test_rounded_cube_multi_face_solid", + "eval.tests.test_units.test_unit_variants_all_import", + "eval.tests.test_units.test_unit_variants_cardinal_geometry", + "eval.tests.test_units.test_unit_variants_have_identical_output", + "eval.tests.test_units.test_unit_variants_share_struct" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_cross_stream_sync.test_cube_obj_group_zero_face_span_matches_vertex_count", + "reasons": [ + { + "id": "if_no_else", + "message": "pytest test has a conditional assertion with no else branch", + "path": "eval/tests/test_cross_stream_sync.py", + "repair_hint": "Add an else branch that fails, or assert the condition before making conditional checks.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_output.test_mm_and_m_produce_identical_stdout", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_golden_output.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_output.test_mm_m_and_in_committed_goldens_mutually_equal", + "reasons": [ + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_golden_output.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_cli_errors.test_bare_dash_argument_rejected", + "eval.tests.test_cli_errors.test_empty_iges_print_exact_loading_diagnostic", + "eval.tests.test_cli_errors.test_empty_string_argument_rejected", + "eval.tests.test_cli_errors.test_extra_arguments_ignored_uses_first", + "eval.tests.test_cli_errors.test_filename_extension_selection[.hidden]", + "eval.tests.test_cli_errors.test_filename_extension_selection[README]", + "eval.tests.test_cli_errors.test_filename_extension_selection[build.sh]", + "eval.tests.test_cli_errors.test_filename_extension_selection[data]", + "eval.tests.test_cli_errors.test_filename_extension_selection[filewithnoextension]", + "eval.tests.test_cli_errors.test_first_argument_wins_over_second", + "eval.tests.test_cli_errors.test_flag_like_argument_without_dot_rejected[--help]", + "eval.tests.test_cli_errors.test_flag_like_argument_without_dot_rejected[--version]", + "eval.tests.test_cli_errors.test_flag_like_argument_without_dot_rejected[-file]", + "eval.tests.test_cli_errors.test_flag_like_argument_without_dot_rejected[-h]", + "eval.tests.test_cli_errors.test_flag_like_argument_without_dot_rejected[-v]", + "eval.tests.test_cli_errors.test_garbage_iges_rejects_without_entities", + "eval.tests.test_cli_errors.test_garbage_iges_with_binary_bytes_rejected", + "eval.tests.test_cli_errors.test_malformed_brep_rejected_with_exact_diagnostic[.brep]", + "eval.tests.test_cli_errors.test_malformed_brep_rejected_with_exact_diagnostic[.brp]", + "eval.tests.test_cli_errors.test_malformed_iges_rejected_with_loading_error[.iges]", + "eval.tests.test_cli_errors.test_malformed_iges_rejected_with_loading_error[.igs]", + "eval.tests.test_cli_errors.test_malformed_step_content_silently_rejected[.step]", + "eval.tests.test_cli_errors.test_malformed_step_content_silently_rejected[.stp]", + "eval.tests.test_cli_errors.test_nested_multidot_last_extension_wins[a.b.rounded-cube.step]", + "eval.tests.test_cli_errors.test_nested_multidot_last_extension_wins[archive.cube.step]", + "eval.tests.test_cli_errors.test_nested_multidot_last_extension_wins[version2.model.STEP]", + "eval.tests.test_cli_errors.test_no_arguments_does_not_create_obj_file", + "eval.tests.test_cli_errors.test_no_arguments_exits_nonzero_with_empty_output", + "eval.tests.test_cli_errors.test_non_cad_trailing_extension_boundary[FIG.TAR.GZ]", + "eval.tests.test_cli_errors.test_non_cad_trailing_extension_boundary[a.b.CsV]", + "eval.tests.test_cli_errors.test_non_cad_trailing_extension_boundary[data.zip]", + "eval.tests.test_cli_errors.test_non_cad_trailing_extension_boundary[dot]", + "eval.tests.test_cli_errors.test_non_cad_trailing_extension_boundary[trailingdot.]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.brep]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.brp]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.iges]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.igs]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.step]", + "eval.tests.test_cli_errors.test_nonexistent_file_rejected_for_all_formats[.stp]", + "eval.tests.test_cli_errors.test_second_file_argument_pointing_at_missing_file_ignored", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[3mf]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[csv]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[dae]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[dat]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[fbx]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[glb]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[iges2]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[json]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[obj]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[off]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[ply]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[step2]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[stl]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[txt]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[xml]", + "eval.tests.test_cli_errors.test_unrecognised_extension_rejected[xyz]", + "eval.tests.test_cli_success.test_brep_and_brp_synonyms_import[.brep]", + "eval.tests.test_cli_success.test_brep_and_brp_synonyms_import[.brp]", + "eval.tests.test_cli_success.test_cube_mesh_dump_geometry[cube-10x10.iges]", + "eval.tests.test_cli_success.test_cube_mesh_dump_geometry[cube-10x10.stp]", + "eval.tests.test_cli_success.test_cube_mesh_dump_geometry[cube.stp]", + "eval.tests.test_cli_success.test_each_face_vertex_triangle_balance", + "eval.tests.test_cli_success.test_every_stdout_mesh_has_node_dump_line[as1_pe_203.brep]", + "eval.tests.test_cli_success.test_every_stdout_mesh_has_node_dump_line[cube-10x10.iges]", + "eval.tests.test_cli_success.test_every_stdout_mesh_has_node_dump_line[cube.stp]", + "eval.tests.test_cli_success.test_iges_and_igs_synonyms_import[.iges]", + "eval.tests.test_cli_success.test_iges_and_igs_synonyms_import[.igs]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[as1_pe_203.brep]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[conical-surface.step]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[cube-10x10.iges]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[cube-fcstd.step]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[cube.stp]", + "eval.tests.test_cli_success.test_import_succeeds_all_formats[rounded-cube.step]", + "eval.tests.test_cli_success.test_input_file_case_does_not_affect_geometry", + "eval.tests.test_cli_success.test_mesh_dump_block_counts[as1_pe_203.brep-18]", + "eval.tests.test_cli_success.test_mesh_dump_block_counts[conical-surface.step-1]", + "eval.tests.test_cli_success.test_mesh_dump_block_counts[cube-10x10.iges-1]", + "eval.tests.test_cli_success.test_mesh_dump_block_counts[cube.stp-1]", + "eval.tests.test_cli_success.test_mesh_dump_block_counts[rounded-cube.step-1]", + "eval.tests.test_cli_success.test_node_dump_conical_unsaved", + "eval.tests.test_cli_success.test_node_dump_cube_stp_colored_red", + "eval.tests.test_cli_success.test_node_dump_iges_solid1", + "eval.tests.test_cli_success.test_node_dump_mesh_body_has_color", + "eval.tests.test_cli_success.test_node_dump_nested_part_cube_hierarchy", + "eval.tests.test_cli_success.test_node_dump_rounded_cube_named_body", + "eval.tests.test_cli_success.test_repeated_runs_byte_identical_stdout[as1_pe_203.brep]", + "eval.tests.test_cli_success.test_repeated_runs_byte_identical_stdout[cube-10x10.iges]", + "eval.tests.test_cli_success.test_repeated_runs_byte_identical_stdout[rounded-cube.step]", + "eval.tests.test_cli_success.test_step_and_stp_synonyms_import_same_mesh[.step]", + "eval.tests.test_cli_success.test_step_and_stp_synonyms_import_same_mesh[.stp]", + "eval.tests.test_cli_success.test_success_emits_exact_pause_stderr[as1_pe_203.brep]", + "eval.tests.test_cli_success.test_success_emits_exact_pause_stderr[cube-10x10.iges]", + "eval.tests.test_cli_success.test_success_emits_exact_pause_stderr[cube-fcstd.step]", + "eval.tests.test_cli_success.test_success_emits_exact_pause_stderr[cube.stp]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[as1_pe_203.brep-MODEL.BRP]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[as1_pe_203.brep-model.BrEp]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[cube-10x10.iges-MODEL.IGES]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[cube-10x10.iges-cube.Igs]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[rounded-cube.step-MODEL.STEP]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[rounded-cube.step-cube.STP]", + "eval.tests.test_cli_success.test_uppercase_and_mixed_case_extensions_accepted[rounded-cube.step-model.StEp]", + "eval.tests.test_cross_stream_sync.test_brep_obj_groups_match_stdout_mesh_ordinal", + "eval.tests.test_cross_stream_sync.test_cube_obj_face_index_offset_matches_stdout_triangles", + "eval.tests.test_cross_stream_sync.test_cube_obj_group_zero_face_span_matches_vertex_count", + "eval.tests.test_cross_stream_sync.test_dotted_directory_component_path_imports", + "eval.tests.test_cross_stream_sync.test_dotted_directory_step_extension_selected_not_dir_dot", + "eval.tests.test_cross_stream_sync.test_mesh_block_count_equals_obj_group_count[as1_pe_203.brep]", + "eval.tests.test_cross_stream_sync.test_mesh_block_count_equals_obj_group_count[conical-surface.step]", + "eval.tests.test_cross_stream_sync.test_mesh_block_count_equals_obj_group_count[cube-10x10.iges]", + "eval.tests.test_cross_stream_sync.test_mesh_block_count_equals_obj_group_count[cube.stp]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[as1_pe_203.brep]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[conical-surface.step]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[cube-10x10.iges]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[cube-fcstd.step]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[cube-in.step]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[cube.stp]", + "eval.tests.test_cross_stream_sync.test_obj_vertex_count_equals_normal_count[rounded-cube.step]", + "eval.tests.test_cross_stream_sync.test_relative_slash_path_imports[a/b/part.STEP]", + "eval.tests.test_cross_stream_sync.test_relative_slash_path_imports[mdl/part.step]", + "eval.tests.test_cross_stream_sync.test_relative_slash_path_imports[part.step]", + "eval.tests.test_cross_stream_sync.test_result_obj_three_stage_lifecycle", + "eval.tests.test_cross_stream_sync.test_stdout_and_obj_vertex_multiset_counts_agree[cube-10x10.iges]", + "eval.tests.test_cross_stream_sync.test_stdout_and_obj_vertex_multiset_counts_agree[cube-fcstd.step]", + "eval.tests.test_cross_stream_sync.test_stdout_and_obj_vertex_multiset_counts_agree[cube-in.step]", + "eval.tests.test_cross_stream_sync.test_stdout_and_obj_vertex_multiset_counts_agree[cube.stp]", + "eval.tests.test_cross_stream_sync.test_stdout_and_obj_vertex_multiset_counts_agree[rounded-cube.step]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[as1_pe_203.brep]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[conical-surface.step]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[cube-10x10.iges]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[cube-fcstd.step]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[cube-in.step]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[cube.stp]", + "eval.tests.test_cross_stream_sync.test_stdout_triangle_count_equals_obj_face_count[rounded-cube.step]", + "eval.tests.test_cross_stream_sync.test_stdout_vertex_triples_equal_obj_vertices_in_order[cube-10x10.iges]", + "eval.tests.test_cross_stream_sync.test_stdout_vertex_triples_equal_obj_vertices_in_order[cube-fcstd.step]", + "eval.tests.test_cross_stream_sync.test_stdout_vertex_triples_equal_obj_vertices_in_order[cube-in.step]", + "eval.tests.test_cross_stream_sync.test_stdout_vertex_triples_equal_obj_vertices_in_order[cube.stp]", + "eval.tests.test_cross_stream_sync.test_stdout_vertex_triples_equal_obj_vertices_in_order[rounded-cube.step]", + "eval.tests.test_cross_stream_sync.test_surface_and_multi_solid_vertex_count_divergence_is_stable[as1_pe_203.brep]", + "eval.tests.test_cross_stream_sync.test_surface_and_multi_solid_vertex_count_divergence_is_stable[conical-surface.step]", + "eval.tests.test_format_gating.test_cad_extension_directory_aborts_with_ios_failure[bundle.stp]", + "eval.tests.test_format_gating.test_cad_extension_directory_aborts_with_ios_failure[dir.iges]", + "eval.tests.test_format_gating.test_cad_extension_directory_aborts_with_ios_failure[shape.brep]", + "eval.tests.test_format_gating.test_cad_extension_directory_aborts_with_ios_failure[x.step]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[as1_pe_203.brep-model.iges-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[as1_pe_203.brep-model.igs-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[as1_pe_203.brep-model.step-]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[cube-10x10.iges-model.brep-File was not written with this version of the topology\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[cube-10x10.iges-model.step-]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[cube-10x10.iges-model.stp-]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[cube.stp-model.brp-File was not written with this version of the topology\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[cube.stp-model.iges-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[rounded-cube.step-model.brep-File was not written with this version of the topology\\n]", + "eval.tests.test_format_gating.test_cross_format_content_rejected_by_extension_gate[rounded-cube.step-model.igs-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_emits_diagnostic_and_no_mesh[as1_pe_203.brep-model.iges-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_emits_diagnostic_and_no_mesh[cube-10x10.iges-model.brep-File was not written with this version of the topology\\n]", + "eval.tests.test_format_gating.test_cross_format_emits_diagnostic_and_no_mesh[rounded-cube.step-model.brep-File was not written with this version of the topology\\n]", + "eval.tests.test_format_gating.test_cross_format_emits_diagnostic_and_no_mesh[rounded-cube.step-model.igs-\\x1b[32;1mFile not found : temp.igs\\x1b[0m\\n]", + "eval.tests.test_format_gating.test_cross_format_same_bytes_reimports_when_correctly_named[as1_pe_203.brep-model.iges]", + "eval.tests.test_format_gating.test_cross_format_same_bytes_reimports_when_correctly_named[cube-10x10.iges-model.step]", + "eval.tests.test_format_gating.test_cross_format_same_bytes_reimports_when_correctly_named[cube.stp-model.brep]", + "eval.tests.test_format_gating.test_cross_format_same_bytes_reimports_when_correctly_named[rounded-cube.step-model.igs]", + "eval.tests.test_format_gating.test_dotless_directory_returns_one_cleanly", + "eval.tests.test_format_gating.test_existing_result_obj_is_truncated_and_replaced", + "eval.tests.test_format_gating.test_failed_import_leaves_existing_obj_unmodified", + "eval.tests.test_format_gating.test_mesh_dump_precedes_node_tree[as1_pe_203.brep]", + "eval.tests.test_format_gating.test_mesh_dump_precedes_node_tree[cube-10x10.iges]", + "eval.tests.test_format_gating.test_mesh_dump_precedes_node_tree[cube.stp]", + "eval.tests.test_format_gating.test_mesh_end_line_has_exact_trailing_space[as1_pe_203.brep-18]", + "eval.tests.test_format_gating.test_mesh_end_line_has_exact_trailing_space[cube.stp-1]", + "eval.tests.test_format_gating.test_mesh_end_line_has_exact_trailing_space[rounded-cube.step-1]", + "eval.tests.test_format_gating.test_node_tree_starts_with_unnamed_root_line", + "eval.tests.test_format_gating.test_regular_file_with_dotless_name_still_rejected", + "eval.tests.test_format_gating.test_step_cross_format_is_totally_silent[as1_pe_203.brep-model.step]", + "eval.tests.test_format_gating.test_step_cross_format_is_totally_silent[cube-10x10.iges-model.step]", + "eval.tests.test_format_gating.test_step_cross_format_is_totally_silent[cube-10x10.iges-model.stp]", + "eval.tests.test_format_gating.test_unrecognized_extension_directory_returns_one_cleanly[data.stl]", + "eval.tests.test_format_gating.test_unrecognized_extension_directory_returns_one_cleanly[doc.txt]", + "eval.tests.test_format_gating.test_unrecognized_extension_directory_returns_one_cleanly[notes.obj]", + "eval.tests.test_format_gating.test_unrecognized_extension_directory_returns_one_cleanly[readme.md]", + "eval.tests.test_golden_output.test_distinct_geometry_goldens_are_not_byte_equal[as1_pe_203.brep-golden_as1_pe_203.txt]", + "eval.tests.test_golden_output.test_distinct_geometry_goldens_are_not_byte_equal[conical-surface.step-golden_conical-surface.txt]", + "eval.tests.test_golden_output.test_distinct_geometry_goldens_are_not_byte_equal[cube.stp-golden_cube.txt]", + "eval.tests.test_golden_output.test_distinct_geometry_goldens_are_not_byte_equal[rounded-cube.step-golden_rounded-cube.txt]", + "eval.tests.test_golden_output.test_mm_and_m_produce_identical_stdout", + "eval.tests.test_golden_output.test_mm_m_and_in_committed_goldens_mutually_equal", + "eval.tests.test_golden_output.test_stdout_matches_golden[as1_pe_203.brep-golden_as1_pe_203.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[conical-surface.step-golden_conical-surface.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-10x10.iges-golden_cube-10x10.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-10x10.stp-golden_cube-10x10_step.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-fcstd.step-golden_cube-fcstd.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-in.step-golden_cube-in.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-m.step-golden_cube-m.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube-mm.step-golden_cube-mm.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[cube.stp-golden_cube.txt]", + "eval.tests.test_golden_output.test_stdout_matches_golden[rounded-cube.step-golden_rounded-cube.txt]", + "eval.tests.test_node_tree_structure.test_brep_all_mesh_end_lines_have_exact_trailing_space", + "eval.tests.test_node_tree_structure.test_brep_dump_geometry_totals", + "eval.tests.test_node_tree_structure.test_brep_node_tree_mesh_count_equals_mesh_block_count", + "eval.tests.test_node_tree_structure.test_brep_root_has_no_named_children", + "eval.tests.test_node_tree_structure.test_brep_root_meshes_have_no_color_tuple", + "eval.tests.test_node_tree_structure.test_colour_bytes_are_valid_unit_interval", + "eval.tests.test_node_tree_structure.test_colour_tuple_branch_values_are_exact[cube-10x10.iges- Mesh: Solid1 (0, 0, 0)]", + "eval.tests.test_node_tree_structure.test_colour_tuple_branch_values_are_exact[cube-10x10.stp- Mesh: Cube 10x10 (0, 0, 0)]", + "eval.tests.test_node_tree_structure.test_colour_tuple_branch_values_are_exact[cube.stp- Mesh: cube (1, 0.318547, 0)]", + "eval.tests.test_node_tree_structure.test_coloured_mesh_emits_exact_color_tuple[conical-surface.step- Mesh: (Unsaved) (0.351533, 0.351533, 0.351533)]", + "eval.tests.test_node_tree_structure.test_coloured_mesh_emits_exact_color_tuple[cube-fcstd.step- Mesh: Cube (0.603827, 0.603827, 0.603827)]", + "eval.tests.test_node_tree_structure.test_coloured_mesh_emits_exact_color_tuple[rounded-cube.step- Mesh: Body (0.603827, 0.603827, 0.603827)]", + "eval.tests.test_node_tree_structure.test_consecutive_tree_levels_indent_by_exactly_two", + "eval.tests.test_node_tree_structure.test_mesh_block_count_equals_tree_mesh_line_count[as1_pe_203.brep]", + "eval.tests.test_node_tree_structure.test_mesh_block_count_equals_tree_mesh_line_count[cube-10x10.iges]", + "eval.tests.test_node_tree_structure.test_mesh_block_count_equals_tree_mesh_line_count[rounded-cube.step]", + "eval.tests.test_node_tree_structure.test_nested_unit_tree_is_three_levels", + "eval.tests.test_node_tree_structure.test_root_node_is_unnamed_first_tree_line[as1_pe_203.brep]", + "eval.tests.test_node_tree_structure.test_root_node_is_unnamed_first_tree_line[cube-10x10.iges]", + "eval.tests.test_node_tree_structure.test_root_node_is_unnamed_first_tree_line[rounded-cube.step]", + "eval.tests.test_node_tree_structure.test_two_level_tree_root_plus_single_child[cube-10x10.iges-expected_arrows1]", + "eval.tests.test_node_tree_structure.test_two_level_tree_root_plus_single_child[cube-10x10.stp-expected_arrows3]", + "eval.tests.test_node_tree_structure.test_two_level_tree_root_plus_single_child[cube-fcstd.step-expected_arrows2]", + "eval.tests.test_node_tree_structure.test_two_level_tree_root_plus_single_child[rounded-cube.step-expected_arrows0]", + "eval.tests.test_obj_structure.test_brep_multi_mesh_obj_is_large", + "eval.tests.test_obj_structure.test_cube_unit_extent_is_meter_fixed", + "eval.tests.test_obj_structure.test_face_count_matches_stdout_triangle_count", + "eval.tests.test_obj_structure.test_face_indices_within_range_and_global_unique", + "eval.tests.test_obj_structure.test_face_lines_have_vvn_form[as1_pe_203.brep]", + "eval.tests.test_obj_structure.test_face_lines_have_vvn_form[cube-10x10.iges]", + "eval.tests.test_obj_structure.test_face_lines_have_vvn_form[rounded-cube.step]", + "eval.tests.test_obj_structure.test_face_lines_use_normal_index_equal_to_vertex_index", + "eval.tests.test_obj_structure.test_last_face_index_equals_vertex_count", + "eval.tests.test_obj_structure.test_mm_and_m_steps_produce_same_vertices", + "eval.tests.test_obj_structure.test_normal_lines_are_numeric_triples", + "eval.tests.test_obj_structure.test_obj_vertex_and_face_counts[as1_pe_203.brep-4068]", + "eval.tests.test_obj_structure.test_obj_vertex_and_face_counts[conical-surface.step-1012]", + "eval.tests.test_obj_structure.test_obj_vertex_and_face_counts[cube-10x10.iges-24]", + "eval.tests.test_obj_structure.test_obj_vertex_and_face_counts[cube.stp-24]", + "eval.tests.test_obj_structure.test_obj_vertex_and_face_counts[rounded-cube.step-98]", + "eval.tests.test_obj_structure.test_per_mesh_groups_increment_from_zero", + "eval.tests.test_obj_structure.test_single_mesh_has_single_group_zero", + "eval.tests.test_obj_structure.test_vertex_blocks_contiguous_between_groups", + "eval.tests.test_obj_structure.test_vertex_blocks_follow_each_group_line", + "eval.tests.test_obj_structure.test_vertex_lines_are_numeric_triples[conical-surface.step]", + "eval.tests.test_obj_structure.test_vertex_lines_are_numeric_triples[cube.stp]", + "eval.tests.test_obj_structure.test_vertex_lines_are_numeric_triples[rounded-cube.step]", + "eval.tests.test_obj_structure.test_vertex_normal_balance" + ] + } + }, + "commit": "41e470890ae0f9dc69ac50ffd5fc73e03576f4eb", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.12515582958053, + "eval_clean_hashes": [ + "cd2990318b384d3edc31c0050d23df9107dee2958d8822fd5c436ff7544f2086" + ], + "input_record": { + "commit": "41e470890ae0f9dc69ac50ffd5fc73e03576f4eb", + "difficulty": "easy", + "difficulty_code_lines": 1334, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 1334, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.12515582958053, + "difficulty_test_code_lines": 619, + "full_name": "kovacsv/occt-import-js", + "input_joern_zip": "cpp_joern/kovacsv__occt-import-js.zip", + "joern_status": true, + "joern_time": 7.983165247133002, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "OSGeo/gdal", + "rank": 659, + "similarity": 0.43509912490844727 + }, + { + "pb_fullname": "OSGeo/PROJ", + "rank": 439, + "similarity": 0.4105033278465271 + } + ], + "repo_path": "cpp/kovacsv__occt-import-js", + "source": "commit:41e470890ae0f9dc69ac50ffd5fc73e03576f4eb", + "status": "done", + "url": "https://github.com/kovacsv/occt-import-js" + }, + "instance_id": "kovacsv__occt-import-js.41e4708", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "kovacsv/occt-import-js" +} diff --git a/kovacsv--occt-import-js.41e4708/tests/test.sh b/kovacsv--occt-import-js.41e4708/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kovacsv--occt-import-js.41e4708/tests/workspace.tar.gz b/kovacsv--occt-import-js.41e4708/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..26e81190154663417ebdf7a91573b99ccb8437b3 --- /dev/null +++ b/kovacsv--occt-import-js.41e4708/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9ededaa0ba5330521af2f88ccb3fe49cc3a3c859c172c6b1276040c05ecaf7c +size 36866 diff --git a/kovetskiy--manul.b036c31/environment/Dockerfile b/kovetskiy--manul.b036c31/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/kovetskiy--manul.b036c31/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kovetskiy--manul.b036c31/environment/download.sh b/kovetskiy--manul.b036c31/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..2b87a1de889f15094ae954bb321b0e6f3a78fc65 --- /dev/null +++ b/kovetskiy--manul.b036c31/environment/download.sh @@ -0,0 +1,124 @@ +#!/usr/bin/env bash +# ProgramGym download stage for github.com/kovetskiy/manul. +# This script is sourced (not executed) and is completely standalone: it reads +# no repository file. It generates the pinned module metadata inline in a fixed +# temporary directory and prefetches the Go module dependencies into the +# default module cache so the offline build.sh can compile without network +# access. It performs no compile, link, test, or package step. +# +# The repository vendors dependencies as git submodules that are NOT checked +# out (an unpopulated vendor/ tree), so module mode is the single build path: +# the inline module metadata carries the runtime closure, and build.sh builds +# the root main package strictly from the prefetched module cache. + +# Never let the Go command try to resolve a newer toolchain over the network. +export GOTOOLCHAIN=local + +# Fixed literal directory for the standalone temporary module metadata. +MANUL_MODULE_DIR="/tmp/manul-module" + +if [ -d "$MANUL_MODULE_DIR" ]; then + rm -rf "$MANUL_MODULE_DIR" +fi +mkdir -p "$MANUL_MODULE_DIR" + +# Write the pinned go.mod inline. All dependency metadata is embedded here +# explicitly (never read from the repository) so download.sh works from an empty +# mount that only contains download.sh itself. Direct requires are pinned to the +# repository's declared git submodule SHAs; the rest of the closure is the +# deterministically resolved module set. +cat > "$MANUL_MODULE_DIR/go.mod" <<'GO_MOD_EOF' +module github.com/kovetskiy/manul + +go 1.25.0 + +require ( + github.com/PuerkitoBio/goquery v1.1.0 + github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34 + github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9 + github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c + github.com/reconquest/karma-go v1.3.1 + github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb +) + +require ( + github.com/BurntSushi/toml v1.6.0 // indirect + github.com/andybalholm/cascadia v1.3.4 // indirect + github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da // indirect + github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f // indirect + github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851 // indirect + github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f // indirect + github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce // indirect + github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) +GO_MOD_EOF + +# Write the pinned go.sum inline for integrity and determinism the offline +# build can verify without network access. +cat > "$MANUL_MODULE_DIR/go.sum" <<'GO_SUM_EOF' +github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= +github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/PuerkitoBio/goquery v1.1.0 h1:QUDKATbrxlrC/VtTGXPgSF28dtBbniZz0X2sp/Twom4= +github.com/PuerkitoBio/goquery v1.1.0/go.mod h1:T9ezsOHcCrDCgA8aF1Cqr3sSYbO/xgdy8/R/XiIMAhA= +github.com/andybalholm/cascadia v1.3.4 h1:vM2lgh0Vru9Vwyfm4cQqWP2HHMW0u0+2PAW7Q38Qufg= +github.com/andybalholm/cascadia v1.3.4/go.mod h1:BLRmbRjpEtNKieZOCCvYj4RqN+KRA41GBe/5O+G93kM= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34 h1:bUWVdQQT5QLGFudBaGJE9v3Zf0EdDiDd5h8vAj9sMVg= +github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34/go.mod h1:u+dvDLWaaxNkHMvhUK1IBXTNS3fhDvdy3BqQrZM8w/k= +github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9 h1:WQBvXZ7/w+R4aDYyuaYQLdExbSZkWEQTJRPxR9jIXc4= +github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9/go.mod h1:B8HeKAukXULNzWWsW5k/SQyDkiQZPn7lTBJDB46MZ9I= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da h1:xBUNZBPFlY8zFDh5RKYjDmTZIR3N4f0o5ca0uiGxIJM= +github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da/go.mod h1:/3bq4ExKQqS6ePDFGWVTGxRjjjxsTbq82ECn6SGjrck= +github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f h1:z1ngdCBGkIqhguiSVsn7VI/PLzGnC6r1JClA4iv+5hA= +github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f/go.mod h1:63UJzHtKBhZ2qo6JzQFn8wOG8bNXextZyVOjlXUE+9I= +github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c h1:FKFbqo3jX8v172fJF+mMGTsY9pqQHLKNbuM9m6veJH8= +github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c/go.mod h1:dF8sYs86hXr+kKjDVvxDZYMUsTm5yr0PFQqLer/xsrk= +github.com/reconquest/karma-go v1.3.1 h1:3CUEBIgDtZmlzhwHxb06uhShzniRbQT5GQIBeLLtFGg= +github.com/reconquest/karma-go v1.3.1/go.mod h1:52XRXXa2ec/VNrlCirwasdJfNmjI1O87q098gmqILh0= +github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb h1:XQFItkGkamH3Wnpz4LxmC8y9SQchkQmFgCV8ySRmCzg= +github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb/go.mod h1:dvTh1eTEb2Ve7iUpKXtPU+PuvB7cOoG+nza2sj0/Vk8= +github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851 h1:o2J6abTvFylmmepI2GgNSeZZlUUz4xz3UStWIY6EXLk= +github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851/go.mod h1:tpO+vNC9ppBvJErZXrQpfwiVDuza5k1nRWH7SrutKtY= +github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f h1:IA86P8l4xRMNbd021H3fGgdIT/B5D/bvdT0xsMqOC/c= +github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f/go.mod h1:xyNcU6XK6bQpR3pVBIHFPi4Xh6NV/FBKnWkYV8lwv1k= +github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce h1:bNhTHXC0NX1wo3nGVdM6LZL+90Qx1NVBYDlw9+H9IMw= +github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce/go.mod h1:H3Pgo5dsVfGXxKBNju4XnzDKLcejXSgBY7y5t+LDk24= +github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= +github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446 h1:75pcOSsb40+ub185cJI7g5uykl9Uu76rD5ONzK/4s40= +github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446/go.mod h1:NtepZ8TEXErPsmQDMUoN72f8aIy4+xNinSJ3f1giess= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +GO_SUM_EOF + +# Prefetch the pinned dependencies into the default module cache so the offline +# build.sh can compile without network access. Module mode is used explicitly +# (via the inline -modfile). Change into the fixed directory first, because Go +# still discovers the module root from the current working directory. +cd "$MANUL_MODULE_DIR" + +if ! go mod download -modfile="$MANUL_MODULE_DIR/go.mod"; then + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kovetskiy--manul.b036c31/environment/executable b/kovetskiy--manul.b036c31/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..e24e2bc6bc09f0ee1bd65c644f8a8b9e1f77889a --- /dev/null +++ b/kovetskiy--manul.b036c31/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaf2fe32e5cff6455817d07f138382b093930fde3e70126a016bcade77ba5625 +size 10815880 diff --git a/kovetskiy--manul.b036c31/environment/programgym-go.tar.gz b/kovetskiy--manul.b036c31/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kovetskiy--manul.b036c31/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kovetskiy--manul.b036c31/environment/workspace.tar.gz b/kovetskiy--manul.b036c31/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c39ba5ac6c6ff94ebb3d031d0cf45644260b9174 --- /dev/null +++ b/kovetskiy--manul.b036c31/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9100a68ba6051567c5d030d2f343e27d0fac423a5cad891ee8ac6e3afaa7114c +size 33465 diff --git a/kovetskiy--manul.b036c31/instruction.md b/kovetskiy--manul.b036c31/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kovetskiy--manul.b036c31/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kovetskiy--manul.b036c31/solution/solve.sh b/kovetskiy--manul.b036c31/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kovetskiy--manul.b036c31/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kovetskiy--manul.b036c31/task.toml b/kovetskiy--manul.b036c31/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1a0eaec5ab740512a106fa17592305a4ce2f4ab7 --- /dev/null +++ b/kovetskiy--manul.b036c31/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kovetskiy--manul.b036c31" +description = "Synthetic ProgramGym cleanroom reconstruction task for kovetskiy/manul" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kovetskiy__manul.b036c31" +repository = "kovetskiy/manul" +commit = "b036c31e292f34236b4dd30146b62e3b826d53c1" +language = "go" +difficulty = "easy" +difficulty_score = 1.0534626049254552 +test_branches = 5 +test_count = 284 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kovetskiy--manul.b036c31/tests/Dockerfile b/kovetskiy--manul.b036c31/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_01.tar.gz b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..068bb64be05de8ca54824af789063c39097457fb --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1eb1f5c2343f71385919e68eb841fee20471791923477684c33c095f2c37ad5 +size 10210 diff --git a/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_02.tar.gz b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f931a23c0d3b2e286a8ebe3cd13a92a3d84790d0 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15694acc277466ec436da6060f4df87356fa8bb75a4e62b9e32249f94a567a38 +size 6404 diff --git a/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_03.tar.gz b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2fd5ba3659367fa06dbe6dd838d0d301314772f2 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0457454836163fc6145abc804012a1b8cfa9be920a542a777fd803e70c8bd03 +size 6004 diff --git a/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_04.tar.gz b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8338aa14e1ad074988ea88a28db3599fd723ed2d --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b6af779a7e732a740402b8b8ebb3eb0f5295e454e44ff84583165b052dca617b +size 8865 diff --git a/kovetskiy--manul.b036c31/tests/blobs/tests/generated_upstream.tar.gz b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2049d10554ec0dd25f22662e79364158ff81714f --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:150a9715afba51cac6881d3493f4a78234aeac0c42f83e48be434d922d64b97e +size 3309 diff --git a/kovetskiy--manul.b036c31/tests/download.sh b/kovetskiy--manul.b036c31/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..2b87a1de889f15094ae954bb321b0e6f3a78fc65 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/download.sh @@ -0,0 +1,124 @@ +#!/usr/bin/env bash +# ProgramGym download stage for github.com/kovetskiy/manul. +# This script is sourced (not executed) and is completely standalone: it reads +# no repository file. It generates the pinned module metadata inline in a fixed +# temporary directory and prefetches the Go module dependencies into the +# default module cache so the offline build.sh can compile without network +# access. It performs no compile, link, test, or package step. +# +# The repository vendors dependencies as git submodules that are NOT checked +# out (an unpopulated vendor/ tree), so module mode is the single build path: +# the inline module metadata carries the runtime closure, and build.sh builds +# the root main package strictly from the prefetched module cache. + +# Never let the Go command try to resolve a newer toolchain over the network. +export GOTOOLCHAIN=local + +# Fixed literal directory for the standalone temporary module metadata. +MANUL_MODULE_DIR="/tmp/manul-module" + +if [ -d "$MANUL_MODULE_DIR" ]; then + rm -rf "$MANUL_MODULE_DIR" +fi +mkdir -p "$MANUL_MODULE_DIR" + +# Write the pinned go.mod inline. All dependency metadata is embedded here +# explicitly (never read from the repository) so download.sh works from an empty +# mount that only contains download.sh itself. Direct requires are pinned to the +# repository's declared git submodule SHAs; the rest of the closure is the +# deterministically resolved module set. +cat > "$MANUL_MODULE_DIR/go.mod" <<'GO_MOD_EOF' +module github.com/kovetskiy/manul + +go 1.25.0 + +require ( + github.com/PuerkitoBio/goquery v1.1.0 + github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34 + github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9 + github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c + github.com/reconquest/karma-go v1.3.1 + github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb +) + +require ( + github.com/BurntSushi/toml v1.6.0 // indirect + github.com/andybalholm/cascadia v1.3.4 // indirect + github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da // indirect + github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f // indirect + github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851 // indirect + github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f // indirect + github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce // indirect + github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) +GO_MOD_EOF + +# Write the pinned go.sum inline for integrity and determinism the offline +# build can verify without network access. +cat > "$MANUL_MODULE_DIR/go.sum" <<'GO_SUM_EOF' +github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= +github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/PuerkitoBio/goquery v1.1.0 h1:QUDKATbrxlrC/VtTGXPgSF28dtBbniZz0X2sp/Twom4= +github.com/PuerkitoBio/goquery v1.1.0/go.mod h1:T9ezsOHcCrDCgA8aF1Cqr3sSYbO/xgdy8/R/XiIMAhA= +github.com/andybalholm/cascadia v1.3.4 h1:vM2lgh0Vru9Vwyfm4cQqWP2HHMW0u0+2PAW7Q38Qufg= +github.com/andybalholm/cascadia v1.3.4/go.mod h1:BLRmbRjpEtNKieZOCCvYj4RqN+KRA41GBe/5O+G93kM= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34 h1:bUWVdQQT5QLGFudBaGJE9v3Zf0EdDiDd5h8vAj9sMVg= +github.com/kovetskiy/godocs v0.0.0-20160817104724-2d9428f80f34/go.mod h1:u+dvDLWaaxNkHMvhUK1IBXTNS3fhDvdy3BqQrZM8w/k= +github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9 h1:WQBvXZ7/w+R4aDYyuaYQLdExbSZkWEQTJRPxR9jIXc4= +github.com/kovetskiy/lorg v0.0.0-20160822124726-7cb623cb98d9/go.mod h1:B8HeKAukXULNzWWsW5k/SQyDkiQZPn7lTBJDB46MZ9I= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da h1:xBUNZBPFlY8zFDh5RKYjDmTZIR3N4f0o5ca0uiGxIJM= +github.com/reconquest/callbackwriter-go v0.0.0-20160818100920-951e238f72da/go.mod h1:/3bq4ExKQqS6ePDFGWVTGxRjjjxsTbq82ECn6SGjrck= +github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f h1:z1ngdCBGkIqhguiSVsn7VI/PLzGnC6r1JClA4iv+5hA= +github.com/reconquest/executil-go v0.0.0-20181110204642-1f5c2d67813f/go.mod h1:63UJzHtKBhZ2qo6JzQFn8wOG8bNXextZyVOjlXUE+9I= +github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c h1:FKFbqo3jX8v172fJF+mMGTsY9pqQHLKNbuM9m6veJH8= +github.com/reconquest/hierr-go v0.0.0-20170127051027-5322b90dda9c/go.mod h1:dF8sYs86hXr+kKjDVvxDZYMUsTm5yr0PFQqLer/xsrk= +github.com/reconquest/karma-go v1.3.1 h1:3CUEBIgDtZmlzhwHxb06uhShzniRbQT5GQIBeLLtFGg= +github.com/reconquest/karma-go v1.3.1/go.mod h1:52XRXXa2ec/VNrlCirwasdJfNmjI1O87q098gmqILh0= +github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb h1:XQFItkGkamH3Wnpz4LxmC8y9SQchkQmFgCV8ySRmCzg= +github.com/reconquest/lexec-go v0.0.0-20170221063622-bc3b4d045eeb/go.mod h1:dvTh1eTEb2Ve7iUpKXtPU+PuvB7cOoG+nza2sj0/Vk8= +github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851 h1:o2J6abTvFylmmepI2GgNSeZZlUUz4xz3UStWIY6EXLk= +github.com/reconquest/lineflushwriter-go v0.0.0-20200921103343-b9b8d10a6851/go.mod h1:tpO+vNC9ppBvJErZXrQpfwiVDuza5k1nRWH7SrutKtY= +github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f h1:IA86P8l4xRMNbd021H3fGgdIT/B5D/bvdT0xsMqOC/c= +github.com/reconquest/nopio-go v0.0.0-20161213101805-20796acb207f/go.mod h1:xyNcU6XK6bQpR3pVBIHFPi4Xh6NV/FBKnWkYV8lwv1k= +github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce h1:bNhTHXC0NX1wo3nGVdM6LZL+90Qx1NVBYDlw9+H9IMw= +github.com/reconquest/ser-go v0.0.0-20181114141834-0d1f485292ce/go.mod h1:H3Pgo5dsVfGXxKBNju4XnzDKLcejXSgBY7y5t+LDk24= +github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= +github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446 h1:75pcOSsb40+ub185cJI7g5uykl9Uu76rD5ONzK/4s40= +github.com/zazab/zhash v0.0.0-20221031090444-2b0d50417446/go.mod h1:NtepZ8TEXErPsmQDMUoN72f8aIy4+xNinSJ3f1giess= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +GO_SUM_EOF + +# Prefetch the pinned dependencies into the default module cache so the offline +# build.sh can compile without network access. Module mode is used explicitly +# (via the inline -modfile). Change into the fixed directory first, because Go +# still discovers the module root from the current working directory. +cd "$MANUL_MODULE_DIR" + +if ! go mod download -modfile="$MANUL_MODULE_DIR/go.mod"; then + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kovetskiy--manul.b036c31/tests/executable b/kovetskiy--manul.b036c31/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..e24e2bc6bc09f0ee1bd65c644f8a8b9e1f77889a --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaf2fe32e5cff6455817d07f138382b093930fde3e70126a016bcade77ba5625 +size 10815880 diff --git a/kovetskiy--manul.b036c31/tests/programgym-go.tar.gz b/kovetskiy--manul.b036c31/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kovetskiy--manul.b036c31/tests/programgym_evaluator.py b/kovetskiy--manul.b036c31/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kovetskiy--manul.b036c31/tests/programgym_task.json b/kovetskiy--manul.b036c31/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..c066f0da3a6452fc97960c8cf47c905871dc091b --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/programgym_task.json @@ -0,0 +1,525 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_main.test_bare_double_dash_separator_usage_error", + "eval.tests.test_main.test_bare_only_vendored_flag_usage_error", + "eval.tests.test_main.test_both_internal_flags_stripped_simultaneously", + "eval.tests.test_main.test_clean_empty[long]", + "eval.tests.test_main.test_clean_empty[short]", + "eval.tests.test_main.test_clean_recursive_verbose_fatal_not_masked", + "eval.tests.test_main.test_clean_with_testing_flag", + "eval.tests.test_main.test_duplicate_only_vendored_flag_rejected", + "eval.tests.test_main.test_duplicate_remove_subcommand_rejected", + "eval.tests.test_main.test_extra_parse_error_forms[lowercase-q]", + "eval.tests.test_main.test_extra_parse_error_forms[query-equals-form]", + "eval.tests.test_main.test_extra_parse_error_forms[unknown-equals-form]", + "eval.tests.test_main.test_getwd_fault_when_cwd_deleted[clean]", + "eval.tests.test_main.test_getwd_fault_when_cwd_deleted[help]", + "eval.tests.test_main.test_getwd_fault_when_cwd_deleted[tree]", + "eval.tests.test_main.test_getwd_fault_when_cwd_deleted[version]", + "eval.tests.test_main.test_getwd_fault_with_no_args", + "eval.tests.test_main.test_help_long_flag_prints_full_usage", + "eval.tests.test_main.test_help_long_wins_over_subcommand", + "eval.tests.test_main.test_help_short_prints_full_usage_on_stdout", + "eval.tests.test_main.test_help_wins_over_only_vendored_option", + "eval.tests.test_main.test_help_wins_over_recursive_clean", + "eval.tests.test_main.test_help_wins_over_subcommand", + "eval.tests.test_main.test_help_wins_over_trace", + "eval.tests.test_main.test_help_wins_over_two_subcommands", + "eval.tests.test_main.test_help_wins_over_verbose", + "eval.tests.test_main.test_import_option_accepted_on_non_tree_subcommand", + "eval.tests.test_main.test_import_option_accepted_on_query_subcommand", + "eval.tests.test_main.test_in_non_git_dir_submodule_status_fatal[clean]", + "eval.tests.test_main.test_in_non_git_dir_submodule_status_fatal[install]", + "eval.tests.test_main.test_in_non_git_dir_submodule_status_fatal[query-only-vendored]", + "eval.tests.test_main.test_in_non_git_dir_submodule_status_fatal[query]", + "eval.tests.test_main.test_in_non_git_dir_submodule_status_fatal[remove]", + "eval.tests.test_main.test_insecure_skip_verify_flag_final_position", + "eval.tests.test_main.test_insecure_skip_verify_flag_stripped", + "eval.tests.test_main.test_insecure_skip_verify_stripped_for_tree", + "eval.tests.test_main.test_install_all_empty[long]", + "eval.tests.test_main.test_install_all_empty[short]", + "eval.tests.test_main.test_install_dashdash_positional_as_dependency", + "eval.tests.test_main.test_install_empty_version_target", + "eval.tests.test_main.test_install_single_equals_extracts_name", + "eval.tests.test_main.test_install_testing_unknown_dependency", + "eval.tests.test_main.test_install_too_many_equals", + "eval.tests.test_main.test_install_two_deps_first_unknown", + "eval.tests.test_main.test_install_unknown_dependency", + "eval.tests.test_main.test_install_unknown_with_version", + "eval.tests.test_main.test_install_with_testing_flag", + "eval.tests.test_main.test_integration_test_flag_final_position", + "eval.tests.test_main.test_integration_test_flag_stripped", + "eval.tests.test_main.test_interleaved_internal_flags_and_logging", + "eval.tests.test_main.test_multiple_subcommands_are_rejected[clean+query]", + "eval.tests.test_main.test_multiple_subcommands_are_rejected[install+remove]", + "eval.tests.test_main.test_multiple_subcommands_are_rejected[query+clean]", + "eval.tests.test_main.test_multiple_subcommands_are_rejected[query+update]", + "eval.tests.test_main.test_no_arguments_prints_usage_to_stderr", + "eval.tests.test_main.test_no_arguments_usage_has_no_options_section", + "eval.tests.test_main.test_option_o_rejected_on_non_query_subcommand[clean]", + "eval.tests.test_main.test_option_o_rejected_on_non_query_subcommand[install]", + "eval.tests.test_main.test_option_o_rejected_on_non_query_subcommand[remove]", + "eval.tests.test_main.test_option_o_rejected_on_non_query_subcommand[tree]", + "eval.tests.test_main.test_option_o_rejected_on_non_query_subcommand[update]", + "eval.tests.test_main.test_query_combined_import_onlyvendored_testing", + "eval.tests.test_main.test_query_dispatch_empty[long]", + "eval.tests.test_main.test_query_dispatch_empty[short]", + "eval.tests.test_main.test_query_long_only_vendored_flag", + "eval.tests.test_main.test_query_only_vendored_empty_no_output", + "eval.tests.test_main.test_query_only_vendored_with_testing", + "eval.tests.test_main.test_query_recursive_only_vendored_no_fatal", + "eval.tests.test_main.test_query_with_testing_flag_nonrecursive", + "eval.tests.test_main.test_recursive_longform_verbose_query_fatal", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[clean-recursive]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[install-recursive]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[query-long-recursive]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[query-recursive-tests]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[query-recursive]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[query-tests-then-recursive]", + "eval.tests.test_main.test_recursive_with_empty_imports_fails[update-recursive]", + "eval.tests.test_main.test_remove_all_empty[long]", + "eval.tests.test_main.test_remove_all_empty[short]", + "eval.tests.test_main.test_remove_does_not_split_equals", + "eval.tests.test_main.test_remove_ignores_recursive_and_testing", + "eval.tests.test_main.test_remove_ignores_recursive_flag", + "eval.tests.test_main.test_remove_unknown_dependency", + "eval.tests.test_main.test_remove_with_testing_flag", + "eval.tests.test_main.test_subcommand_conflict_query_remove_rejected", + "eval.tests.test_main.test_subcommand_conflict_tree_query_rejected", + "eval.tests.test_main.test_subcommand_conflict_update_clean_rejected", + "eval.tests.test_main.test_testing_long_form_query", + "eval.tests.test_main.test_testing_long_form_tree", + "eval.tests.test_main.test_trace_alone_no_subcommand_usage_error", + "eval.tests.test_main.test_trace_enables_trace_logging", + "eval.tests.test_main.test_trace_query_emits_trace_logging", + "eval.tests.test_main.test_trace_query_recursive_fatal_not_masked", + "eval.tests.test_main.test_trace_shows_go_list_exec_start", + "eval.tests.test_main.test_trace_update_unknown_fatal_still_fails", + "eval.tests.test_main.test_trace_with_fatal_still_fails", + "eval.tests.test_main.test_tree_empty_lists_packages[long]", + "eval.tests.test_main.test_tree_empty_lists_packages[short]", + "eval.tests.test_main.test_tree_import_flag[long]", + "eval.tests.test_main.test_tree_import_flag[short]", + "eval.tests.test_main.test_tree_with_all_three_tolerated_flags", + "eval.tests.test_main.test_tree_with_recursive_flag", + "eval.tests.test_main.test_tree_with_testing_flag", + "eval.tests.test_main.test_unknown_flag_prints_usage_and_fails[long-unknown-2]", + "eval.tests.test_main.test_unknown_flag_prints_usage_and_fails[long-unknown]", + "eval.tests.test_main.test_unknown_flag_prints_usage_and_fails[question-flag]", + "eval.tests.test_main.test_unknown_flag_prints_usage_and_fails[short-unknown]", + "eval.tests.test_main.test_update_all_empty[long]", + "eval.tests.test_main.test_update_all_empty[short]", + "eval.tests.test_main.test_update_dashdash_positional_as_dependency", + "eval.tests.test_main.test_update_recursive_unknown_dependency", + "eval.tests.test_main.test_update_single_equals_extracts_name", + "eval.tests.test_main.test_update_too_many_equals", + "eval.tests.test_main.test_update_unknown_dependency", + "eval.tests.test_main.test_update_with_testing_flag", + "eval.tests.test_main.test_verbose_alone_no_subcommand_usage_error", + "eval.tests.test_main.test_verbose_alone_with_bare_option_usage_error", + "eval.tests.test_main.test_verbose_emits_exec_args", + "eval.tests.test_main.test_verbose_enables_debug_logging", + "eval.tests.test_main.test_verbose_long_form_alone_usage_error", + "eval.tests.test_main.test_verbose_long_form_clean_emits_debug", + "eval.tests.test_main.test_verbose_long_form_fatal_not_masked", + "eval.tests.test_main.test_verbose_long_form_query_emits_debug", + "eval.tests.test_main.test_verbose_long_form_remove", + "eval.tests.test_main.test_verbose_long_form_tree_stdout_stderr_separation", + "eval.tests.test_main.test_verbose_long_form_with_trace_precedence", + "eval.tests.test_main.test_verbose_plus_trace_configures_both_levels", + "eval.tests.test_main.test_verbose_query_emits_debug_logging", + "eval.tests.test_main.test_verbose_query_only_vendored_no_output", + "eval.tests.test_main.test_verbose_tree_lists_packages_and_debug", + "eval.tests.test_main.test_verbose_with_fatal_still_fails", + "eval.tests.test_main.test_version_prints_version", + "eval.tests.test_main.test_version_wins_over_duplicate_subcommands_and_option", + "eval.tests.test_main.test_version_wins_over_multiple_subcommands", + "eval.tests.test_main.test_version_wins_over_recursive_clean", + "eval.tests.test_main.test_version_wins_over_subcommand", + "eval.tests.test_main.test_version_wins_over_update_with_dependency", + "eval.tests.test_main.test_version_with_trace_flag", + "eval.tests.test_main.test_version_with_verbose_flag" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_module_02_empty_module.test_empty_module_named_install_parses_bogus_package", + "eval.tests.test_module_02_empty_module.test_empty_module_only_vendored_query_empty", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[clean]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[clean_recursive]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[install]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[query]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[query_recursive]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[query_testing]", + "eval.tests.test_module_02_empty_module.test_empty_module_parse_imports_warns_then_fails[update]", + "eval.tests.test_module_02_empty_module.test_empty_module_remove_empty", + "eval.tests.test_module_02_empty_module.test_empty_module_tree_decodes_warning_as_fatal[tree]", + "eval.tests.test_module_02_empty_module.test_empty_module_tree_decodes_warning_as_fatal[tree_import]", + "eval.tests.test_module_02_empty_module.test_empty_module_tree_decodes_warning_as_fatal[tree_recursive]", + "eval.tests.test_module_02_empty_module.test_empty_module_tree_decodes_warning_as_fatal[tree_testing]", + "eval.tests.test_module_02_imports.test_clean_empty_repo_nothing_to_remove", + "eval.tests.test_module_02_imports.test_clean_recursive_aborts_on_empty_test_packages", + "eval.tests.test_module_02_imports.test_help_long_form_includes_all_four_action_flags", + "eval.tests.test_module_02_imports.test_help_switches_print_usage_to_stdout", + "eval.tests.test_module_02_imports.test_install_empty_repo_all_already_vendored", + "eval.tests.test_module_02_imports.test_install_named_version_split_validation", + "eval.tests.test_module_02_imports.test_install_too_many_equals_delimiters", + "eval.tests.test_module_02_imports.test_install_unknown_named_dependency", + "eval.tests.test_module_02_imports.test_no_args_prints_usage_to_stderr_and_fails", + "eval.tests.test_module_02_imports.test_non_git_clean_reaches_imports_then_fails_git", + "eval.tests.test_module_02_imports.test_non_git_install_named_reaches_imports_then_fails_git", + "eval.tests.test_module_02_imports.test_non_git_install_reaches_imports_then_fails_git", + "eval.tests.test_module_02_imports.test_non_git_query_remove_fail_git_status[query]", + "eval.tests.test_module_02_imports.test_non_git_query_remove_fail_git_status[query_only_vendored]", + "eval.tests.test_module_02_imports.test_non_git_query_remove_fail_git_status[remove]", + "eval.tests.test_module_02_imports.test_non_git_query_remove_fail_git_status[remove_named]", + "eval.tests.test_module_02_imports.test_non_git_tree_lists_literal_pattern", + "eval.tests.test_module_02_imports.test_non_git_update_named_reaches_imports_then_fails_git", + "eval.tests.test_module_02_imports.test_non_git_update_noargs_reaches_imports_then_fails_git", + "eval.tests.test_module_02_imports.test_query_non_vendored_reaches_imports", + "eval.tests.test_module_02_imports.test_query_only_vendored_empty_repo", + "eval.tests.test_module_02_imports.test_query_recursive_and_testing_aborts", + "eval.tests.test_module_02_imports.test_query_recursive_empty_repo_aborts_on_empty_test_packages", + "eval.tests.test_module_02_imports.test_query_testing_only_empty_repo_succeeds", + "eval.tests.test_module_02_imports.test_remove_empty_repo_exits_zero", + "eval.tests.test_module_02_imports.test_remove_named_with_equals_is_unknown", + "eval.tests.test_module_02_imports.test_remove_unknown_named_dependency", + "eval.tests.test_module_02_imports.test_tree_literal_pattern_variants[tree]", + "eval.tests.test_module_02_imports.test_tree_literal_pattern_variants[tree_import]", + "eval.tests.test_module_02_imports.test_tree_literal_pattern_variants[tree_recursive]", + "eval.tests.test_module_02_imports.test_tree_literal_pattern_variants[tree_recursive_testing]", + "eval.tests.test_module_02_imports.test_tree_literal_pattern_variants[tree_testing]", + "eval.tests.test_module_02_imports.test_unknown_flag_prints_usage_to_stderr", + "eval.tests.test_module_02_imports.test_update_empty_repo_nothing_to_update", + "eval.tests.test_module_02_imports.test_update_too_many_equals_delimiters", + "eval.tests.test_module_02_imports.test_update_unknown_named_dependency", + "eval.tests.test_module_02_imports.test_verbose_flag_alone_is_not_an_action", + "eval.tests.test_module_02_imports.test_version_prints_exact_string", + "eval.tests.test_module_02_imports.test_version_wins_over_verbose" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_submodule.test_aggregate_help_contains_all_subcommands", + "eval.tests.test_submodule.test_clean_fails_outside_git_repo", + "eval.tests.test_submodule.test_commit_hash_from_git_status_printed", + "eval.tests.test_submodule.test_deep_vendor_path_only_prefix_trimmed", + "eval.tests.test_submodule.test_empty_repo_lists_nothing", + "eval.tests.test_submodule.test_help_lists_testing_and_recursive_flags", + "eval.tests.test_submodule.test_help_prints_usage_to_stdout[long_help]", + "eval.tests.test_submodule.test_help_prints_usage_to_stdout[short_help]", + "eval.tests.test_submodule.test_invalid_flag_prints_usage_and_fails", + "eval.tests.test_submodule.test_leading_dash_prefix_trimmed", + "eval.tests.test_submodule.test_multiple_vendor_submodule_lines_match_as_set", + "eval.tests.test_submodule.test_nested_vendor_dirname_not_matched", + "eval.tests.test_submodule.test_no_arguments_shows_usage_and_fails", + "eval.tests.test_submodule.test_non_vendor_submodule_filtered_out", + "eval.tests.test_submodule.test_only_non_vendor_submodules_lists_nothing", + "eval.tests.test_submodule.test_query_non_vendored_mode_also_requires_git_repo", + "eval.tests.test_submodule.test_query_only_vendored_fails_outside_git_repo", + "eval.tests.test_submodule.test_remove_all_with_empty_vendors_map_succeeds_silently", + "eval.tests.test_submodule.test_remove_all_without_gitmodules_dir_fails", + "eval.tests.test_submodule.test_remove_dependency_writes_info_to_stderr", + "eval.tests.test_submodule.test_remove_unknown_dependency_errors", + "eval.tests.test_submodule.test_single_vendor_submodule_listed", + "eval.tests.test_submodule.test_two_vendor_submodules_padded_to_max_length", + "eval.tests.test_submodule.test_two_vendor_submodules_same_length_no_padding", + "eval.tests.test_submodule.test_unregistered_gitlink_makes_status_fail", + "eval.tests.test_submodule.test_update_known_vendored_dep_then_fails_pull", + "eval.tests.test_submodule.test_update_too_many_equal_signs_errors", + "eval.tests.test_submodule.test_update_unknown_dependency_errors", + "eval.tests.test_submodule.test_update_with_version_parses_importpath", + "eval.tests.test_submodule.test_vendor_name_shortest_pads_to_widest", + "eval.tests.test_submodule.test_version_prints_to_stdout" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_clean.test_clean_dependency_not_in_query_after", + "eval.tests.test_clean.test_clean_long_flag_dispatch", + "eval.tests.test_clean.test_clean_nothing_to_remove_empty", + "eval.tests.test_clean.test_clean_recursive_fails_on_empty_imports_before_removing", + "eval.tests.test_clean.test_clean_removed_dependency_no_longer_vendored", + "eval.tests.test_clean.test_clean_removes_multiple_unused_plural", + "eval.tests.test_clean.test_clean_removes_unused_vendored_submodule", + "eval.tests.test_clean.test_clean_second_run_is_noop", + "eval.tests.test_install.test_install_explicit_unknown_dependency", + "eval.tests.test_install.test_install_long_flag_no_deps", + "eval.tests.test_install.test_install_long_flag_unknown_dep", + "eval.tests.test_install.test_install_no_deps_all_already_vendored", + "eval.tests.test_install.test_install_no_deps_empty_repo_noop", + "eval.tests.test_install.test_install_too_many_equals_fails", + "eval.tests.test_install.test_install_vendored_dep_still_unknown", + "eval.tests.test_query.test_query_does_not_write_files", + "eval.tests.test_query.test_query_long_flag_dispatch_matches_short", + "eval.tests.test_query.test_query_non_git_directory_fails_submodule_status", + "eval.tests.test_query.test_query_non_vendored_does_not_print_vendored_only", + "eval.tests.test_query.test_query_non_vendored_empty_project_no_rows", + "eval.tests.test_query.test_query_o_short_flag_alone_rejected", + "eval.tests.test_query.test_query_only_vendored_commit_matches_git", + "eval.tests.test_query.test_query_only_vendored_empty_repo_no_output", + "eval.tests.test_query.test_query_only_vendored_ignores_recursive_and_testing", + "eval.tests.test_query.test_query_only_vendored_lists_pinned_commit", + "eval.tests.test_query.test_query_only_vendored_pads_shorter_paths", + "eval.tests.test_query.test_query_only_vendored_three_paths_width_uses_longest", + "eval.tests.test_query.test_query_only_vendored_two_equal_lengths", + "eval.tests.test_query.test_query_only_vendored_unknown_long_flag_rejected", + "eval.tests.test_query.test_query_plain_non_vendored_non_git_fails", + "eval.tests.test_query.test_query_recursive_empty_repo_errors", + "eval.tests.test_query.test_query_single_vendor_single_space_no_padding", + "eval.tests.test_remove.test_remove_all_removes_every_vendor", + "eval.tests.test_remove.test_remove_does_not_parse_equals", + "eval.tests.test_remove.test_remove_known_dependency_removes_submodule", + "eval.tests.test_remove.test_remove_long_flag", + "eval.tests.test_remove.test_remove_missing_dependency_fails", + "eval.tests.test_remove.test_remove_multiple_dependencies", + "eval.tests.test_remove.test_remove_removed_submodule_no_longer_in_query", + "eval.tests.test_remove.test_remove_with_no_submodules_is_noop", + "eval.tests.test_tree.test_tree_empty_repo_prints_root", + "eval.tests.test_tree.test_tree_import_and_testing_together", + "eval.tests.test_tree.test_tree_import_flag_uses_path", + "eval.tests.test_tree.test_tree_long_flag", + "eval.tests.test_tree.test_tree_testing_flag_includes_tests", + "eval.tests.test_tree.test_tree_verbose_flag", + "eval.tests.test_update.test_update_garbage_commit_fails", + "eval.tests.test_update.test_update_long_flag_dispatch", + "eval.tests.test_update.test_update_no_dep_no_submodules_is_noop", + "eval.tests.test_update.test_update_to_specific_commit", + "eval.tests.test_update.test_update_too_many_equals_fails", + "eval.tests.test_update.test_update_unknown_dependency_fails", + "eval.tests.test_update.test_update_vendored_dependency_succeeds" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_contracts.test_help_prints_full_usage_document", + "eval.tests.test_cli_contracts.test_long_help_is_equivalent", + "eval.tests.test_cli_contracts.test_no_args_prints_usage_to_stderr_and_fails", + "eval.tests.test_cli_contracts.test_query_only_vendored_empty_repo_is_silent", + "eval.tests.test_cli_contracts.test_query_only_vendored_requires_git_repo", + "eval.tests.test_cli_contracts.test_query_std_library_only_project_prints_nothing", + "eval.tests.test_cli_contracts.test_unknown_flag_prints_usage_to_stderr_and_fails", + "eval.tests.test_cli_contracts.test_version_flag_prints_version_and_exits_zero" + ] + } + }, + "commit": "b036c31e292f34236b4dd30146b62e3b826d53c1", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.0534626049254552, + "eval_clean_hashes": [ + "eaf2fe32e5cff6455817d07f138382b093930fde3e70126a016bcade77ba5625" + ], + "input_record": { + "commit": "b036c31e292f34236b4dd30146b62e3b826d53c1", + "commits": 88, + "contributors": 10, + "difficulty": "easy", + "difficulty_code_lines": 1131, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 1131, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.0534626049254552, + "difficulty_test_code_lines": 0, + "full_name": "kovetskiy/manul", + "github_stars": 659, + "input_joern_zip": "go_joern/kovetskiy__manul.zip", + "joern_status": true, + "joern_time": 12.474181218072772, + "language": "go", + "pb_match": [ + { + "pb_fullname": "antonmedv/walk", + "rank": 528, + "similarity": 0.48536717891693115 + }, + { + "pb_fullname": "go-critic/go-critic", + "rank": 131, + "similarity": 0.5968208909034729 + }, + { + "pb_fullname": "mibk/dupl", + "rank": 91, + "similarity": 0.6021475195884705 + }, + { + "pb_fullname": "JohannesKaufmann/html-to-markdown", + "rank": 459, + "similarity": 0.4922761619091034 + }, + { + "pb_fullname": "mgechev/revive", + "rank": 132, + "similarity": 0.6109917163848877 + }, + { + "pb_fullname": "alecthomas/chroma", + "rank": 774, + "similarity": 0.4617619514465332 + }, + { + "pb_fullname": "mfridman/tparse", + "rank": 249, + "similarity": 0.5534420013427734 + }, + { + "pb_fullname": "gabotechs/dep-tree", + "rank": 381, + "similarity": 0.5299942493438721 + }, + { + "pb_fullname": "cweill/gotests", + "rank": 193, + "similarity": 0.5771296620368958 + }, + { + "pb_fullname": "boyter/scc", + "rank": 725, + "similarity": 0.49376219511032104 + }, + { + "pb_fullname": "incu6us/goimports-reviser", + "rank": 90, + "similarity": 0.559855580329895 + }, + { + "pb_fullname": "sheepla/pingu", + "rank": 183, + "similarity": 0.5251333117485046 + }, + { + "pb_fullname": "kyoh86/richgo", + "rank": 85, + "similarity": 0.6027808785438538 + }, + { + "pb_fullname": "raviqqe/muffet", + "rank": 877, + "similarity": 0.4600924253463745 + }, + { + "pb_fullname": "eliukblau/pixterm", + "rank": 255, + "similarity": 0.5405004024505615 + }, + { + "pb_fullname": "TheZoraiz/ascii-image-converter", + "rank": 215, + "similarity": 0.5173671841621399 + }, + { + "pb_fullname": "cheat/cheat", + "rank": 773, + "similarity": 0.4916171729564667 + }, + { + "pb_fullname": "hooklift/gowsdl", + "rank": 571, + "similarity": 0.526285707950592 + }, + { + "pb_fullname": "psampaz/go-mod-outdated", + "rank": 227, + "similarity": 0.5120181441307068 + }, + { + "pb_fullname": "kisielk/errcheck", + "rank": 52, + "similarity": 0.6455839276313782 + }, + { + "pb_fullname": "dundee/gdu", + "rank": 565, + "similarity": 0.4982801079750061 + }, + { + "pb_fullname": "tomnomnom/gron", + "rank": 969, + "similarity": 0.46980684995651245 + }, + { + "pb_fullname": "hairyhenderson/gomplate", + "rank": 331, + "similarity": 0.5404672622680664 + }, + { + "pb_fullname": "junegunn/fzf", + "rank": 909, + "similarity": 0.45063209533691406 + }, + { + "pb_fullname": "tomarrell/wrapcheck", + "rank": 119, + "similarity": 0.5669759511947632 + } + ], + "repo_age": 10.84, + "repo_path": "go/kovetskiy__manul", + "source": "commit:b036c31e292f34236b4dd30146b62e3b826d53c1", + "status": "done", + "url": "https://github.com/kovetskiy/manul" + }, + "instance_id": "kovetskiy__manul.b036c31", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_upstream", + "iteration_limit": 5, + "module_index": 5, + "module_kind": "tests", + "termination_reason": "max_iterations" + } + ], + "repository": "kovetskiy/manul" +} diff --git a/kovetskiy--manul.b036c31/tests/test.sh b/kovetskiy--manul.b036c31/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kovetskiy--manul.b036c31/tests/workspace.tar.gz b/kovetskiy--manul.b036c31/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c39ba5ac6c6ff94ebb3d031d0cf45644260b9174 --- /dev/null +++ b/kovetskiy--manul.b036c31/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9100a68ba6051567c5d030d2f343e27d0fac423a5cad891ee8ac6e3afaa7114c +size 33465 diff --git a/kpcyrd--rshijack.acf2bc8/environment/Dockerfile b/kpcyrd--rshijack.acf2bc8/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..43b8645e238f0dec6b8d2d8e1929cc231dac70ef --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/Dockerfile @@ -0,0 +1,70 @@ +FROM rust:1.97.1-bookworm +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kpcyrd--rshijack.acf2bc8/environment/docker-compose.yaml b/kpcyrd--rshijack.acf2bc8/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kpcyrd--rshijack.acf2bc8/environment/download.sh b/kpcyrd--rshijack.acf2bc8/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..87ee37c6d4423a3b92c06113debf86c49ac4d8dc --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/download.sh @@ -0,0 +1,576 @@ +#!/bin/sh +# ProgramGym download.sh for rshijack (Rust). +# +# This script is standalone: it must be valid in shell source mode +# (`source /source_ro/download.sh`), must not read any repository source +# file, and must not compile/build anything. Its only job is to prefetch +# every Cargo dependency that the offline `cargo build --offline` will need. +# +# It builds a temporary cargo package from inline data (a generated +# Cargo.toml declaring the crate's direct dependencies, each pinned to its +# exact Cargo.lock-resolved version, plus a generated Cargo.lock that matches +# the repository lockfile) and runs `cargo fetch --manifest-path `. +# The exact locked crate versions are therefore materialized into the shared +# CARGO_HOME registry cache, so the offline build resolves against identical +# versions. +# +# Note: this script deliberately does NOT export CARGO_TARGET_DIR. cargo fetch +# writes only to CARGO_HOME, and any CARGO_TARGET_DIR it exported here (with +# $PWD == /source_ro) would be inherited by the later offline build and point +# at the read-only source mount, causing "Read-only file system" errors. +# build.sh sets CARGO_TARGET_DIR itself to a writable workspace path. + +# Export for build.sh so it reuses the prefetched registry cache. +export CARGO_HOME="${CARGO_HOME:-$HOME/.cargo}" + +# Build the temporary prefetch package away from /source_ro / repo root. +dl_tmp="$(mktemp -d)" +trap 'rm -rf "$dl_tmp"' EXIT + +mkdir -p "$dl_tmp/src" + +# Minimal stub so the temp [lib] package is valid for cargo fetch. +printf 'pub fn stub() {}\n' > "$dl_tmp/src/lib.rs" + +# Generated manifest: declares the crate's direct dependencies and pins each +# to its exact Cargo.lock-resolved version. +cat > "$dl_tmp/Cargo.toml" <<'EOF' +[package] +name = "rshijack-prefetch" +version = "0.0.0" +edition = "2021" + +[lib] +path = "src/lib.rs" + +[dependencies] +anyhow = "=1.0.91" +clap = { version = "=4.5.20", features = ["derive"] } +env_logger = "=0.11.5" +log = "=0.4.22" +pktparse = "=0.7.1" +pnet = "=0.35.0" +EOF + +# Generated lockfile: exact copy of the repository's Cargo.lock (inline data), +# so every crate version the offline build needs is present in the cache. +cat > "$dl_tmp/Cargo.lock" <<'LOCKEOF' +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "anstream" +version = "0.6.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56" + +[[package]] +name = "anstyle-parse" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125" +dependencies = [ + "anstyle", + "windows-sys", +] + +[[package]] +name = "anyhow" +version = "1.0.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c042108f3ed77fd83760a5fd79b53be043192bb3b9dba91d8c574c0ada7850c8" + +[[package]] +name = "clap" +version = "4.5.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.5.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" + +[[package]] +name = "colorchoice" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" + +[[package]] +name = "env_filter" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" +dependencies = [ + "anstream", + "anstyle", + "env_filter", + "humantime", + "log", +] + +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "humantime" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" + +[[package]] +name = "ipnetwork" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf466541e9d546596ee94f9f69590f89473455f88372423e0008fc1a7daf100e" +dependencies = [ + "serde", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "libc" +version = "0.2.161" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1" + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "no-std-net" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43794a0ace135be66a25d3ae77d41b91615fb68ae937f904090203e81f755b65" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "pktparse" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8aeb7ec35e7fdd2ecd56d39d56f843197f243d08cc4d51cf6b37268393d5e1b" +dependencies = [ + "nom", +] + +[[package]] +name = "pnet" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "682396b533413cc2e009fbb48aadf93619a149d3e57defba19ff50ce0201bd0d" +dependencies = [ + "ipnetwork", + "pnet_base", + "pnet_datalink", + "pnet_packet", + "pnet_sys", + "pnet_transport", +] + +[[package]] +name = "pnet_base" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffc190d4067df16af3aba49b3b74c469e611cad6314676eaf1157f31aa0fb2f7" +dependencies = [ + "no-std-net", +] + +[[package]] +name = "pnet_datalink" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e79e70ec0be163102a332e1d2d5586d362ad76b01cec86f830241f2b6452a7b7" +dependencies = [ + "ipnetwork", + "libc", + "pnet_base", + "pnet_sys", + "winapi", +] + +[[package]] +name = "pnet_macros" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13325ac86ee1a80a480b0bc8e3d30c25d133616112bb16e86f712dcf8a71c863" +dependencies = [ + "proc-macro2", + "quote", + "regex", + "syn", +] + +[[package]] +name = "pnet_macros_support" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eed67a952585d509dd0003049b1fc56b982ac665c8299b124b90ea2bdb3134ab" +dependencies = [ + "pnet_base", +] + +[[package]] +name = "pnet_packet" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c96ebadfab635fcc23036ba30a7d33a80c39e8461b8bd7dc7bb186acb96560f" +dependencies = [ + "glob", + "pnet_base", + "pnet_macros", + "pnet_macros_support", +] + +[[package]] +name = "pnet_sys" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d4643d3d4db6b08741050c2f3afa9a892c4244c085a72fcda93c9c2c9a00f4b" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "pnet_transport" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f604d98bc2a6591cf719b58d3203fd882bdd6bf1db696c4ac97978e9f4776bf" +dependencies = [ + "libc", + "pnet_base", + "pnet_packet", + "pnet_sys", +] + +[[package]] +name = "proc-macro2" +version = "1.0.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "rshijack" +version = "0.5.2" +dependencies = [ + "anyhow", + "clap", + "env_logger", + "log", + "pktparse", + "pnet", +] + +[[package]] +name = "serde" +version = "1.0.214" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.214" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "2.0.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +LOCKEOF + +# Prefetch every locked crate into the shared cargo cache, honoring the locked +# versions so the offline build's versions are exactly materialized. +cargo fetch --manifest-path "$dl_tmp/Cargo.toml" + +echo "download.sh: rshijack dependencies prefetched." diff --git a/kpcyrd--rshijack.acf2bc8/environment/executable b/kpcyrd--rshijack.acf2bc8/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..040ef9f2c6eb7091715e542a9acb76a1fbd1e8e0 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b68393ee25b4bf42522c970c1013bfb464cf7a47cce59e0d87b1304705ff4534 +size 2854656 diff --git a/kpcyrd--rshijack.acf2bc8/environment/harbor_configure_apt_mirror.sh b/kpcyrd--rshijack.acf2bc8/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kpcyrd--rshijack.acf2bc8/environment/harbor_prepare_download_env.sh b/kpcyrd--rshijack.acf2bc8/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kpcyrd--rshijack.acf2bc8/environment/workspace.tar.gz b/kpcyrd--rshijack.acf2bc8/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2276b07fa3a292f1737876e610feb3240fb1634e --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5d8b32cc65250ec494196f05e06786f40ce0233f1671a7a54c1c90637b07973 +size 15929 diff --git a/kpcyrd--rshijack.acf2bc8/instruction.md b/kpcyrd--rshijack.acf2bc8/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kpcyrd--rshijack.acf2bc8/solution/solve.sh b/kpcyrd--rshijack.acf2bc8/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kpcyrd--rshijack.acf2bc8/task.toml b/kpcyrd--rshijack.acf2bc8/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..27b1f79e2ad3662c7ee2c6707c3cff140208743d --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kpcyrd--rshijack.acf2bc8" +description = "Synthetic ProgramGym cleanroom reconstruction task for kpcyrd/rshijack" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "rust"] + +[metadata] +source = "ProgramGym" +instance_id = "kpcyrd__rshijack.acf2bc8" +repository = "kpcyrd/rshijack" +commit = "acf2bc844eef9d0789bfc6ed2951881e6401d9b2" +language = "rust" +difficulty = "easy" +difficulty_score = 1.761551988564182 +test_branches = 3 +test_count = 314 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kpcyrd--rshijack.acf2bc8/tests/Dockerfile b/kpcyrd--rshijack.acf2bc8/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..7ac92ae058165211242a0ba5356989bd425ef9ed --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/Dockerfile @@ -0,0 +1,79 @@ +FROM rust:1.97.1-bookworm +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --break-system-packages \ + --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_01.tar.gz b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..79ca402f0695c5ec1abde0874ad39a8008d2be27 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99d1f4cfbbde6a436d5351775a51ba88ee975cfbbf7f90f5e8459f190a6c09bb +size 12884 diff --git a/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_02.tar.gz b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b7404f81d5ac4ddce846e4a84cf9b1964fa5b601 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd9d63ae4a40cf1ef9b973619cc01d75c6751768d6f5f5df03040922b6c83762 +size 18465 diff --git a/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_03.tar.gz b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..55cfc6c2a0d35d1eea484633687fc7a6818b6292 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7a508a9f6cef26540023b95c1a4a0fb499cc2e597e162c4d8ac41e2e3672ae2 +size 13981 diff --git a/kpcyrd--rshijack.acf2bc8/tests/docker-compose.yaml b/kpcyrd--rshijack.acf2bc8/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kpcyrd--rshijack.acf2bc8/tests/download.sh b/kpcyrd--rshijack.acf2bc8/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..87ee37c6d4423a3b92c06113debf86c49ac4d8dc --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/download.sh @@ -0,0 +1,576 @@ +#!/bin/sh +# ProgramGym download.sh for rshijack (Rust). +# +# This script is standalone: it must be valid in shell source mode +# (`source /source_ro/download.sh`), must not read any repository source +# file, and must not compile/build anything. Its only job is to prefetch +# every Cargo dependency that the offline `cargo build --offline` will need. +# +# It builds a temporary cargo package from inline data (a generated +# Cargo.toml declaring the crate's direct dependencies, each pinned to its +# exact Cargo.lock-resolved version, plus a generated Cargo.lock that matches +# the repository lockfile) and runs `cargo fetch --manifest-path `. +# The exact locked crate versions are therefore materialized into the shared +# CARGO_HOME registry cache, so the offline build resolves against identical +# versions. +# +# Note: this script deliberately does NOT export CARGO_TARGET_DIR. cargo fetch +# writes only to CARGO_HOME, and any CARGO_TARGET_DIR it exported here (with +# $PWD == /source_ro) would be inherited by the later offline build and point +# at the read-only source mount, causing "Read-only file system" errors. +# build.sh sets CARGO_TARGET_DIR itself to a writable workspace path. + +# Export for build.sh so it reuses the prefetched registry cache. +export CARGO_HOME="${CARGO_HOME:-$HOME/.cargo}" + +# Build the temporary prefetch package away from /source_ro / repo root. +dl_tmp="$(mktemp -d)" +trap 'rm -rf "$dl_tmp"' EXIT + +mkdir -p "$dl_tmp/src" + +# Minimal stub so the temp [lib] package is valid for cargo fetch. +printf 'pub fn stub() {}\n' > "$dl_tmp/src/lib.rs" + +# Generated manifest: declares the crate's direct dependencies and pins each +# to its exact Cargo.lock-resolved version. +cat > "$dl_tmp/Cargo.toml" <<'EOF' +[package] +name = "rshijack-prefetch" +version = "0.0.0" +edition = "2021" + +[lib] +path = "src/lib.rs" + +[dependencies] +anyhow = "=1.0.91" +clap = { version = "=4.5.20", features = ["derive"] } +env_logger = "=0.11.5" +log = "=0.4.22" +pktparse = "=0.7.1" +pnet = "=0.35.0" +EOF + +# Generated lockfile: exact copy of the repository's Cargo.lock (inline data), +# so every crate version the offline build needs is present in the cache. +cat > "$dl_tmp/Cargo.lock" <<'LOCKEOF' +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "anstream" +version = "0.6.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56" + +[[package]] +name = "anstyle-parse" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125" +dependencies = [ + "anstyle", + "windows-sys", +] + +[[package]] +name = "anyhow" +version = "1.0.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c042108f3ed77fd83760a5fd79b53be043192bb3b9dba91d8c574c0ada7850c8" + +[[package]] +name = "clap" +version = "4.5.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.5.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" + +[[package]] +name = "colorchoice" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" + +[[package]] +name = "env_filter" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" +dependencies = [ + "anstream", + "anstyle", + "env_filter", + "humantime", + "log", +] + +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "humantime" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" + +[[package]] +name = "ipnetwork" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf466541e9d546596ee94f9f69590f89473455f88372423e0008fc1a7daf100e" +dependencies = [ + "serde", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "libc" +version = "0.2.161" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1" + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "no-std-net" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43794a0ace135be66a25d3ae77d41b91615fb68ae937f904090203e81f755b65" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "pktparse" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8aeb7ec35e7fdd2ecd56d39d56f843197f243d08cc4d51cf6b37268393d5e1b" +dependencies = [ + "nom", +] + +[[package]] +name = "pnet" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "682396b533413cc2e009fbb48aadf93619a149d3e57defba19ff50ce0201bd0d" +dependencies = [ + "ipnetwork", + "pnet_base", + "pnet_datalink", + "pnet_packet", + "pnet_sys", + "pnet_transport", +] + +[[package]] +name = "pnet_base" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffc190d4067df16af3aba49b3b74c469e611cad6314676eaf1157f31aa0fb2f7" +dependencies = [ + "no-std-net", +] + +[[package]] +name = "pnet_datalink" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e79e70ec0be163102a332e1d2d5586d362ad76b01cec86f830241f2b6452a7b7" +dependencies = [ + "ipnetwork", + "libc", + "pnet_base", + "pnet_sys", + "winapi", +] + +[[package]] +name = "pnet_macros" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13325ac86ee1a80a480b0bc8e3d30c25d133616112bb16e86f712dcf8a71c863" +dependencies = [ + "proc-macro2", + "quote", + "regex", + "syn", +] + +[[package]] +name = "pnet_macros_support" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eed67a952585d509dd0003049b1fc56b982ac665c8299b124b90ea2bdb3134ab" +dependencies = [ + "pnet_base", +] + +[[package]] +name = "pnet_packet" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c96ebadfab635fcc23036ba30a7d33a80c39e8461b8bd7dc7bb186acb96560f" +dependencies = [ + "glob", + "pnet_base", + "pnet_macros", + "pnet_macros_support", +] + +[[package]] +name = "pnet_sys" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d4643d3d4db6b08741050c2f3afa9a892c4244c085a72fcda93c9c2c9a00f4b" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "pnet_transport" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f604d98bc2a6591cf719b58d3203fd882bdd6bf1db696c4ac97978e9f4776bf" +dependencies = [ + "libc", + "pnet_base", + "pnet_packet", + "pnet_sys", +] + +[[package]] +name = "proc-macro2" +version = "1.0.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "rshijack" +version = "0.5.2" +dependencies = [ + "anyhow", + "clap", + "env_logger", + "log", + "pktparse", + "pnet", +] + +[[package]] +name = "serde" +version = "1.0.214" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.214" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "2.0.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +LOCKEOF + +# Prefetch every locked crate into the shared cargo cache, honoring the locked +# versions so the offline build's versions are exactly materialized. +cargo fetch --manifest-path "$dl_tmp/Cargo.toml" + +echo "download.sh: rshijack dependencies prefetched." diff --git a/kpcyrd--rshijack.acf2bc8/tests/executable b/kpcyrd--rshijack.acf2bc8/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..040ef9f2c6eb7091715e542a9acb76a1fbd1e8e0 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b68393ee25b4bf42522c970c1013bfb464cf7a47cce59e0d87b1304705ff4534 +size 2854656 diff --git a/kpcyrd--rshijack.acf2bc8/tests/harbor_configure_apt_mirror.sh b/kpcyrd--rshijack.acf2bc8/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kpcyrd--rshijack.acf2bc8/tests/harbor_prepare_download_env.sh b/kpcyrd--rshijack.acf2bc8/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kpcyrd--rshijack.acf2bc8/tests/programgym_evaluator.py b/kpcyrd--rshijack.acf2bc8/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kpcyrd--rshijack.acf2bc8/tests/programgym_task.json b/kpcyrd--rshijack.acf2bc8/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..99f6b2665b9b1c410419e018e9bca650f54d3e11 --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/programgym_task.json @@ -0,0 +1,470 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_arg_validation.test_ipv4_session_echoes_decimal_seqack_in_hex", + "eval.tests.test_arg_validation.test_ipv4_session_full_output_matches_golden", + "eval.tests.test_arg_validation.test_port_max_boundary_parses", + "eval.tests.test_arg_validation.test_port_zero_boundary_parses", + "eval.tests.test_arg_validation.test_seq_ack_u32_max_boundary_parses", + "eval.tests.test_arg_validation.test_seq_ack_zero_boundary_echoes_hex", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_ack_duplicate]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_ack_missing_value]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_ack_non_numeric]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_ack_overflow]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_empty_port_src]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_extra_positional]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_invalid_dst]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_invalid_src]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_missing_port_src]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_negative_seq]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_out_of_range_port]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_reset_duplicate]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_sendnull_duplicate]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_seq_duplicate]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_seq_hex]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_seq_missing_value]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_seq_non_numeric]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_seq_overflow]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_unknown_long_flag]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_unknown_short_flag]", + "eval.tests.test_cli_errors.test_clap_error_diagnostic_matches_golden[error_verbose_suggestion]", + "eval.tests.test_cli_errors.test_clap_error_is_closed_by_help_tip_without_trailing_newline", + "eval.tests.test_cli_errors.test_interface_and_src_reports_dst_missing", + "eval.tests.test_cli_errors.test_interface_only_reports_src_and_dst_missing", + "eval.tests.test_cli_errors.test_no_arguments_reports_all_three_required_positionals", + "eval.tests.test_help_version.test_help_appends_shijack_after_help_paragraph", + "eval.tests.test_help_version.test_help_documents_all_three_positionals", + "eval.tests.test_help_version.test_help_documents_quiet_count_flag", + "eval.tests.test_help_version.test_help_documents_reset_flag", + "eval.tests.test_help_version.test_help_documents_send_null_flag", + "eval.tests.test_help_version.test_help_documents_seq_ack_options", + "eval.tests.test_help_version.test_help_full_text_matches_golden", + "eval.tests.test_help_version.test_help_is_never_written_to_stderr", + "eval.tests.test_help_version.test_help_short_flag_is_the_same_alias", + "eval.tests.test_help_version.test_help_with_quiet_global_flag_still_succeeds", + "eval.tests.test_help_version.test_version_long_flag_reports_name_and_dotted_version", + "eval.tests.test_help_version.test_version_short_circuits_even_with_positionals", + "eval.tests.test_help_version.test_version_short_flag_is_an_alias", + "eval.tests.test_help_version.test_version_short_flag_short_circuits_with_positionals", + "eval.tests.test_main_flow.test_banner_is_emitted_then_sniff_interface_error", + "eval.tests.test_main_flow.test_both_seq_ack_use_direct_connection_path", + "eval.tests.test_main_flow.test_direct_seq_ack_reset_accepts_arbitrary_positional_value", + "eval.tests.test_main_flow.test_family_error_contains_exact_combination_message", + "eval.tests.test_main_flow.test_global_quiet_accepted_before_positionals_keeps_info", + "eval.tests.test_main_flow.test_hijack_session_consumes_large_stdin_payload", + "eval.tests.test_main_flow.test_hijack_session_does_not_echo_stdin_to_stderr", + "eval.tests.test_main_flow.test_hijack_session_eof_matches_golden", + "eval.tests.test_main_flow.test_mixed_ipv4_ipv6_src_dst_rejected", + "eval.tests.test_main_flow.test_mixed_ipv6_ipv4_src_dst_rejected", + "eval.tests.test_main_flow.test_only_ack_falls_back_to_sniffing", + "eval.tests.test_main_flow.test_only_seq_falls_back_to_sniffing", + "eval.tests.test_main_flow.test_quiet_does_not_hide_eprintln_lifecycle_lines", + "eval.tests.test_main_flow.test_quiet_double_suppresses_info_log", + "eval.tests.test_main_flow.test_quiet_long_form_suppresses_info_log", + "eval.tests.test_main_flow.test_quiet_single_keeps_info_log", + "eval.tests.test_main_flow.test_quiet_triple_suppresses_info_log", + "eval.tests.test_main_flow.test_reset_after_numeric_boundary_seqack_matches_golden", + "eval.tests.test_main_flow.test_reset_does_not_enter_hijack_session", + "eval.tests.test_main_flow.test_reset_keeps_eprintln_lines_under_quiet", + "eval.tests.test_main_flow.test_reset_long_flag_identical_behavior", + "eval.tests.test_main_flow.test_reset_long_flag_with_send_null_short_circuits", + "eval.tests.test_main_flow.test_reset_seqack_hex_boundary_matches_golden", + "eval.tests.test_main_flow.test_reset_seqack_u32max_matches_golden", + "eval.tests.test_main_flow.test_reset_short_flag_matches_golden", + "eval.tests.test_main_flow.test_reset_suppresses_send_null_branch", + "eval.tests.test_main_flow.test_rust_log_off_suppresses_send_null_info_at_quiet_zero", + "eval.tests.test_main_flow.test_rust_log_warn_overrides_single_quiet_info_log", + "eval.tests.test_main_flow.test_send_null_emits_desync_info_log", + "eval.tests.test_main_flow.test_send_null_long_flag_same_as_short", + "eval.tests.test_main_flow.test_send_null_long_flag_with_double_quiet_full_session", + "eval.tests.test_main_flow.test_send_null_then_session_reaches_exit", + "eval.tests.test_main_flow.test_send_null_with_double_quiet_full_session_matches_golden", + "eval.tests.test_main_flow.test_send_null_with_single_quiet_full_session_matches_golden", + "eval.tests.test_main_flow.test_session_stdout_remains_empty", + "eval.tests.test_main_flow.test_unknown_interface_in_sniff_path_errors" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_net_arg_validation.test_help_long_and_short_flag_share_full_usage[--help]", + "eval.tests.test_net_arg_validation.test_help_long_and_short_flag_share_full_usage[-h]", + "eval.tests.test_net_arg_validation.test_invalid_ack_value_matches_clap_directive[0x10-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_invalid_ack_value_matches_clap_directive[1.5-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_invalid_ack_value_matches_clap_directive[18446744073709551616-number too large to fit in target type]", + "eval.tests.test_net_arg_validation.test_invalid_ack_value_matches_clap_directive[4294967296-4294967296 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_invalid_ack_value_matches_clap_directive[notanum-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_invalid_address_full_diagnostic_block", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[a:b:c-1]", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[a:b:c-2]", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[garbage-value-1]", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[garbage-value-2]", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[not-a-sock-1]", + "eval.tests.test_net_arg_validation.test_invalid_address_value_reports_directive[not-a-sock-2]", + "eval.tests.test_net_arg_validation.test_invalid_seq_value_matches_clap_directive[0x10-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_invalid_seq_value_matches_clap_directive[1.5-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_invalid_seq_value_matches_clap_directive[18446744073709551616-number too large to fit in target type]", + "eval.tests.test_net_arg_validation.test_invalid_seq_value_matches_clap_directive[4294967296-4294967296 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_invalid_seq_value_matches_clap_directive[notanum-invalid digit found in string]", + "eval.tests.test_net_arg_validation.test_missing_individual_arg[-others2]", + "eval.tests.test_net_arg_validation.test_missing_individual_arg[-others0]", + "eval.tests.test_net_arg_validation.test_missing_individual_arg[-others1]", + "eval.tests.test_net_arg_validation.test_missing_option_value[--ack]", + "eval.tests.test_net_arg_validation.test_missing_option_value[--seq]", + "eval.tests.test_net_arg_validation.test_negative_ack_rejected[-1--1 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_negative_ack_rejected[4294967296-4294967296 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_negative_seq_rejected[-1--1 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_negative_seq_rejected[-42--42 is not in 0..=4294967295]", + "eval.tests.test_net_arg_validation.test_no_arguments_errors", + "eval.tests.test_net_arg_validation.test_non_address_dst_positional_rejected", + "eval.tests.test_net_arg_validation.test_unexpected_argument_rejected[--bogus]", + "eval.tests.test_net_arg_validation.test_unexpected_argument_rejected[-Z]", + "eval.tests.test_net_arg_validation.test_unexpected_argument_rejected[1.2.3.4:3:4]", + "eval.tests.test_net_arg_validation.test_unexpected_argument_rejected[extra]", + "eval.tests.test_net_arg_validation.test_version_crate_and_semver[--version]", + "eval.tests.test_net_arg_validation.test_version_crate_and_semver[-V]", + "eval.tests.test_net_arg_validation.test_version_short_circuits_despite_extra_args[--bogus]", + "eval.tests.test_net_arg_validation.test_version_short_circuits_despite_extra_args[-Z]", + "eval.tests.test_net_arg_validation.test_version_short_circuits_despite_extra_args[1.2.3.4:1]", + "eval.tests.test_net_arg_validation.test_version_short_circuits_despite_extra_args[junk]", + "eval.tests.test_net_arg_validation.test_version_short_circuits_despite_extra_args[lo]", + "eval.tests.test_net_ipv4_send.test_interface_cannot_be_found_for_sniff", + "eval.tests.test_net_ipv4_send.test_ipv6_explicit_ports_reach_send", + "eval.tests.test_net_ipv4_send.test_ipv6_send_attempt_reaches_send", + "eval.tests.test_net_ipv4_send.test_mixed_ipv4_src_ipv6_dst_rejected", + "eval.tests.test_net_ipv4_send.test_mixed_ipv6_src_ipv4_dst_rejected", + "eval.tests.test_net_ipv4_send.test_reset_connection_ipv4", + "eval.tests.test_net_ipv4_send.test_reset_echoes_exact_seq_ack[0-0-0x0-0x0]", + "eval.tests.test_net_ipv4_send.test_reset_echoes_exact_seq_ack[1-2-0x1-0x2]", + "eval.tests.test_net_ipv4_send.test_reset_echoes_exact_seq_ack[2147483648-1-0x80000000-0x1]", + "eval.tests.test_net_ipv4_send.test_reset_echoes_exact_seq_ack[4294967295-4294967295-0xffffffff-0xffffffff]", + "eval.tests.test_net_ipv4_send.test_reset_with_send_null_both_flags", + "eval.tests.test_net_ipv4_send.test_send_null_reaches_ipv4_send", + "eval.tests.test_net_ipv4_send.test_send_null_zero_ack_window", + "eval.tests.test_net_ipv4_send.test_stdin_payload_is_sent_then_fin", + "eval.tests.test_net_ipv4_send.test_stdin_payload_sizes[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]", + "eval.tests.test_net_ipv4_send.test_stdin_payload_sizes[]", + "eval.tests.test_net_ipv4_send.test_stdin_payload_sizes[hello world]", + "eval.tests.test_net_ipv4_send.test_stdin_payload_sizes[x]", + "eval.tests.test_net_ipv4_send.test_v6_send_error_block_echoes_exact_seq_ack[0-4294967295-0x0-0xffffffff]", + "eval.tests.test_net_ipv4_send.test_v6_send_error_block_echoes_exact_seq_ack[4294967295-0-0xffffffff-0x0]", + "eval.tests.test_net_ipv4_send.test_v6_send_error_block_echoes_exact_seq_ack[7-9-0x7-0x9]", + "eval.tests.test_net_quiet.test_quiet_gates_info_send_null[quiet_flags0-True]", + "eval.tests.test_net_quiet.test_quiet_gates_info_send_null[quiet_flags1-True]", + "eval.tests.test_net_quiet.test_quiet_gates_info_send_null[quiet_flags2-False]", + "eval.tests.test_net_quiet.test_quiet_gates_info_send_null[quiet_flags3-False]", + "eval.tests.test_net_quiet.test_quiet_gates_info_send_null[quiet_flags4-False]", + "eval.tests.test_net_quiet.test_quiet_long_flag_alias", + "eval.tests.test_net_quiet.test_quiet_never_suppresses_phase_banners", + "eval.tests.test_net_quiet.test_send_null_info_line_has_timestamp_prefix", + "eval.tests.test_net_recv.test_recv_distinct_binary_payload", + "eval.tests.test_net_recv.test_recv_forwards_reverse_payload_exactly_to_stdout[RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR-multi-hundred-bytes]", + "eval.tests.test_net_recv.test_recv_forwards_reverse_payload_exactly_to_stdout[hello from the other side-small-phrase]", + "eval.tests.test_net_recv.test_recv_forwards_reverse_payload_exactly_to_stdout[x-single-byte]", + "eval.tests.test_net_recv.test_recv_reuses_supplied_seq_ack", + "eval.tests.test_net_recv.test_recv_session_logs_and_exits_cleanly", + "eval.tests.test_net_seqack_boundaries.test_ack_negative_rejected", + "eval.tests.test_net_seqack_boundaries.test_ack_only_without_seq_forces_sniff", + "eval.tests.test_net_seqack_boundaries.test_both_seq_and_ack_bypasses_sniff", + "eval.tests.test_net_seqack_boundaries.test_equals_form_onetwentyeightbit_value_rejected", + "eval.tests.test_net_seqack_boundaries.test_positive_equals_form_seq_ack[100-200-0x64-0xc8]", + "eval.tests.test_net_seqack_boundaries.test_positive_equals_form_seq_ack[5-7-0x5-0x7]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_overflow_rejected[--ack---ack -18446744073709551616-number too large to fit in target type]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_overflow_rejected[--ack---ack -4294967296-4294967296 is not in 0..=4294967295]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_overflow_rejected[--seq---seq -18446744073709551616-number too large to fit in target type]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_overflow_rejected[--seq---seq -4294967296-4294967296 is not in 0..=4294967295]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[0-0-0x0-0x0]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[0-4294967295-0x0-0xffffffff]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[1-1-0x1-0x1]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[2147483647-2147483648-0x7fffffff-0x80000000]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[4294967295-0-0xffffffff-0x0]", + "eval.tests.test_net_seqack_boundaries.test_seq_ack_round_trip_hex[4294967295-4294967295-0xffffffff-0xffffffff]", + "eval.tests.test_net_seqack_boundaries.test_seq_only_without_ack_forces_sniff", + "eval.tests.test_net_sniff.test_sniff_dst_port_filter_matches_connection", + "eval.tests.test_net_sniff.test_sniff_observes_loopback_ack", + "eval.tests.test_net_sniff.test_sniff_seq_ack_echoed_as_hex", + "eval.tests.test_net_sniff.test_sniff_then_session_on_observed_packet", + "eval.tests.test_net_sniff.test_sniff_unmatched_src_port_never_reports", + "eval.tests.test_net_sniff.test_unknown_interface_sniff_errors", + "eval.tests.test_net_sniff_verbose.test_sniff_default_verbosity_emits_eth_parse_line", + "eval.tests.test_net_sniff_verbose.test_sniff_default_verbosity_emits_ip4_parse_line", + "eval.tests.test_net_sniff_verbose.test_sniff_default_verbosity_emits_tcp_parse_line", + "eval.tests.test_net_sniff_verbose.test_sniff_quiet_suppresses_debug_parse_lines", + "eval.tests.test_net_sniff_wildcard.test_sniff_ipv4_udp_non_tcp_falls_through", + "eval.tests.test_net_sniff_wildcard.test_sniff_ipv4_unspecified_addr_match", + "eval.tests.test_net_sniff_wildcard.test_sniff_ipv6_concrete_loopback_addr_match", + "eval.tests.test_net_sniff_wildcard.test_sniff_ipv6_udp_non_tcp_falls_through", + "eval.tests.test_net_sniff_wildcard.test_sniff_ipv6_unspecified_addr_match", + "eval.tests.test_net_sniff_wildcard.test_sniff_mixed_v4src_v6dst_never_matches", + "eval.tests.test_net_sniff_wildcard.test_sniff_mixed_v6src_v4dst_never_matches", + "eval.tests.test_net_sniff_wildcard.test_sniff_v4_concrete_ip_port_mismatch_never_reports", + "eval.tests.test_net_sniff_wildcard.test_sniff_v6_addr_mismatch_never_reports", + "eval.tests.test_net_sniff_wildcard.test_sniff_v6_concrete_dest_port_match", + "eval.tests.test_net_sniff_wildcard.test_sniff_v6_matched_ip_port_mismatch_never_reports", + "eval.tests.test_net_stdio_routing.test_error_report_on_stderr", + "eval.tests.test_net_stdio_routing.test_mixed_combination_error_on_stderr", + "eval.tests.test_net_stdio_routing.test_runtime_banners_on_stderr_stdout_empty[argv0-0-Starting hijack session, Please use ^D to terminate.]", + "eval.tests.test_net_stdio_routing.test_runtime_banners_on_stderr_stdout_empty[argv1-0-[+] Connection has been reset]", + "eval.tests.test_net_stdio_routing.test_v6_send_error_on_stderr", + "eval.tests.test_net_v6_send.test_v6_empty_session_fails_on_fin", + "eval.tests.test_net_v6_send.test_v6_full_form_ports_and_origin_parse", + "eval.tests.test_net_v6_send.test_v6_loopback_reset", + "eval.tests.test_net_v6_send.test_v6_reset_echoes_u32_extremes", + "eval.tests.test_net_v6_send.test_v6_reset_reaches_send[0-0-0x0-0x0]", + "eval.tests.test_net_v6_send.test_v6_reset_reaches_send[1-2-0x1-0x2]", + "eval.tests.test_net_v6_send.test_v6_reset_reaches_send[4294967295-7-0xffffffff-0x7]", + "eval.tests.test_net_v6_send.test_v6_send_null_reaches_ipv6_checksum", + "eval.tests.test_net_v6_send.test_v6_session_send_fails_on_first_send" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_arg_validation.test_malformed_dst_with_overlong_port_diagnostic_exact", + "reasons": [ + { + "id": "test_network_dependency", + "message": "test appears to depend on networking", + "path": "eval/tests/test_arg_validation.py", + "repair_hint": "Remove external networking from eval tests; use bundled fixtures or local subprocess behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_arg_validation.test_malformed_src_with_overlong_port_diagnostic_exact", + "reasons": [ + { + "id": "test_network_dependency", + "message": "test appears to depend on networking", + "path": "eval/tests/test_arg_validation.py", + "repair_hint": "Remove external networking from eval tests; use bundled fixtures or local subprocess behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_arg_validation.test_ack_equals_form_malformed_diagnostic_exact[0x2b]", + "eval.tests.test_arg_validation.test_ack_equals_form_malformed_diagnostic_exact[2e3]", + "eval.tests.test_arg_validation.test_ack_equals_form_malformed_diagnostic_exact[no]", + "eval.tests.test_arg_validation.test_ack_u32_max_is_accepted_by_parser", + "eval.tests.test_arg_validation.test_bracketed_ipv6_without_port_dst_is_rejected", + "eval.tests.test_arg_validation.test_bracketed_ipv6_without_port_src_is_rejected", + "eval.tests.test_arg_validation.test_empty_ack_value_diagnostic_exact", + "eval.tests.test_arg_validation.test_empty_seq_value_diagnostic_exact", + "eval.tests.test_arg_validation.test_hostname_like_src_is_rejected_by_value_parser", + "eval.tests.test_arg_validation.test_ipv6_like_src_is_rejected_by_value_parser", + "eval.tests.test_arg_validation.test_malformed_dst_with_empty_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_dst_with_missing_host_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_dst_with_overlong_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_dst_without_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_src_with_empty_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_src_with_missing_host_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_src_with_overlong_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_malformed_src_without_port_diagnostic_exact", + "eval.tests.test_arg_validation.test_missing_all_positionals_exit_is_two", + "eval.tests.test_arg_validation.test_missing_required_positionals_exact_stderr[argv0-err_no_args.txt-no arguments at all]", + "eval.tests.test_arg_validation.test_missing_required_positionals_exact_stderr[argv1-err_only_interface.txt-interface only]", + "eval.tests.test_arg_validation.test_missing_required_positionals_exact_stderr[argv2-err_interface_src_no_dst.txt-interface plus source, destination missing]", + "eval.tests.test_arg_validation.test_near_miss_unknown_flag_suggests_similar_argument", + "eval.tests.test_arg_validation.test_negative_ack_value_is_an_unexpected_argument", + "eval.tests.test_arg_validation.test_negative_seq_value_is_an_unexpected_argument", + "eval.tests.test_arg_validation.test_non_numeric_ack_diagnostic_exact[0x2b]", + "eval.tests.test_arg_validation.test_non_numeric_ack_diagnostic_exact[1.5]", + "eval.tests.test_arg_validation.test_non_numeric_ack_diagnostic_exact[no]", + "eval.tests.test_arg_validation.test_non_numeric_seq_diagnostic_exact[0x1a]", + "eval.tests.test_arg_validation.test_non_numeric_seq_diagnostic_exact[1.2]", + "eval.tests.test_arg_validation.test_non_numeric_seq_diagnostic_exact[abc]", + "eval.tests.test_arg_validation.test_non_numeric_seq_diagnostic_exact[notanum]", + "eval.tests.test_arg_validation.test_seq_equals_form_malformed_diagnostic_exact[ 12]", + "eval.tests.test_arg_validation.test_seq_equals_form_malformed_diagnostic_exact[0x1a]", + "eval.tests.test_arg_validation.test_seq_equals_form_malformed_diagnostic_exact[1.5]", + "eval.tests.test_arg_validation.test_seq_equals_form_malformed_diagnostic_exact[abc]", + "eval.tests.test_arg_validation.test_seq_equals_form_overflow_diagnostic_exact", + "eval.tests.test_arg_validation.test_seq_overflows_u32_diagnostic_exact", + "eval.tests.test_arg_validation.test_seq_u32_max_is_accepted_by_parser", + "eval.tests.test_arg_validation.test_unbracketed_ipv6_with_port_dst_is_rejected", + "eval.tests.test_arg_validation.test_unbracketed_ipv6_with_port_src_is_rejected", + "eval.tests.test_arg_validation.test_unknown_flag_diagnostic_exact[--bogus]", + "eval.tests.test_arg_validation.test_unknown_flag_diagnostic_exact[--extra]", + "eval.tests.test_arg_validation.test_unknown_flag_diagnostic_exact[--xyzzy]", + "eval.tests.test_arg_validation.test_unknown_flag_diagnostic_exact[-Z]", + "eval.tests.test_arg_validation.test_validation_error_ends_with_clap_help_hint", + "eval.tests.test_arg_validation.test_validation_error_leaves_stdout_empty", + "eval.tests.test_envlog.test_global_quiet_after_positionals_suppresses_info", + "eval.tests.test_envlog.test_global_quiet_before_positionals_matches_after", + "eval.tests.test_envlog.test_rust_log_debug_reenables_info_even_under_triple_quiet", + "eval.tests.test_envlog.test_rust_log_error_suppresses_info", + "eval.tests.test_envlog.test_rust_log_info_preserves_info", + "eval.tests.test_envlog.test_rust_log_info_reenables_info_under_double_quiet", + "eval.tests.test_envlog.test_rust_log_off_suppresses_info_at_default_verbosity", + "eval.tests.test_envlog.test_rust_log_trace_keeps_session_exit_clean", + "eval.tests.test_envlog.test_rust_log_trace_preserves_info", + "eval.tests.test_envlog.test_rust_log_trace_reenables_info_under_double_quiet", + "eval.tests.test_error_paths.test_ipv6_reset_send_failure_is_reported", + "eval.tests.test_error_paths.test_ipv6_send_failure_exits_nonzero", + "eval.tests.test_error_paths.test_ipv6_send_failure_is_reported", + "eval.tests.test_error_paths.test_mixed_family_abort_leaves_stdout_empty", + "eval.tests.test_error_paths.test_mixed_family_banner_includes_seq_ack", + "eval.tests.test_error_paths.test_mixed_v4_src_v6_dst_stderr_matches_golden", + "eval.tests.test_error_paths.test_mixed_v6_src_v4_dst_stderr_matches_golden", + "eval.tests.test_error_paths.test_reset_path_exits_zero_with_no_abort", + "eval.tests.test_error_paths.test_reset_path_stderr_matches_golden", + "eval.tests.test_error_paths.test_seq_ack_banner_hex_display", + "eval.tests.test_error_paths.test_unknown_interface_exit_code_is_one", + "eval.tests.test_error_paths.test_unknown_interface_stderr_matches_golden", + "eval.tests.test_error_paths.test_unknown_interface_stdout_stays_empty", + "eval.tests.test_help_version.test_help_leaves_stderr_empty", + "eval.tests.test_help_version.test_help_option_block_verbatim_and_ordered", + "eval.tests.test_help_version.test_help_registers_documented_epilogue_exactly", + "eval.tests.test_help_version.test_help_wins_even_with_extra_positionals", + "eval.tests.test_help_version.test_help_wins_over_missing_required_args", + "eval.tests.test_help_version.test_long_help_stdout_matches_golden", + "eval.tests.test_help_version.test_short_and_long_help_are_identical", + "eval.tests.test_help_version.test_short_help_stdout_matches_golden", + "eval.tests.test_help_version.test_version_is_exact_crate_semver", + "eval.tests.test_help_version.test_version_leaves_stderr_empty", + "eval.tests.test_help_version.test_version_short_flag_matches_golden", + "eval.tests.test_help_version.test_version_stdout_matches_golden", + "eval.tests.test_help_version.test_version_wins_even_with_extra_positionals", + "eval.tests.test_logging.test_double_quiet_suppresses_info_record", + "eval.tests.test_logging.test_info_log_exit_status_is_zero_under_suppression", + "eval.tests.test_logging.test_info_log_preserves_clean_session_exit", + "eval.tests.test_logging.test_info_record_carries_level_and_target", + "eval.tests.test_logging.test_info_record_goes_to_stderr_not_stdout", + "eval.tests.test_logging.test_long_quiet_once_is_equivalent_to_short_quiet", + "eval.tests.test_logging.test_long_quiet_twice_suppresses_info_record", + "eval.tests.test_logging.test_reset_notice_survives_warn_filter", + "eval.tests.test_logging.test_reset_path_emits_no_info_record", + "eval.tests.test_logging.test_send_null_emits_info_record_at_default_verbosity", + "eval.tests.test_logging.test_session_stays_clean_under_deep_quiet", + "eval.tests.test_logging.test_single_quiet_keeps_info_record", + "eval.tests.test_logging.test_triple_quiet_keeps_info_suppressed", + "eval.tests.test_session.test_empty_stdin_terminates_session_cleanly", + "eval.tests.test_session.test_session_after_send_null_shows_info_then_clean_exit", + "eval.tests.test_session.test_session_banner_precedes_stdin_consumption", + "eval.tests.test_session.test_session_consumes_single_byte_stdin", + "eval.tests.test_session.test_session_consumes_small_stdin_payload", + "eval.tests.test_session.test_session_drains_binary_stdin_bytes", + "eval.tests.test_session.test_session_drains_multiblock_stdin", + "eval.tests.test_session.test_session_final_fin_send_then_clean_exit", + "eval.tests.test_session.test_session_shows_startup_banner", + "eval.tests.test_session.test_session_starts_with_banner_then_reads_stdin", + "eval.tests.test_session.test_session_stdout_remains_empty" + ] + } + }, + "commit": "acf2bc844eef9d0789bfc6ed2951881e6401d9b2", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.761551988564182, + "eval_clean_hashes": [ + "b68393ee25b4bf42522c970c1013bfb464cf7a47cce59e0d87b1304705ff4534" + ], + "input_record": { + "codeql_db_mb": 84.12, + "codeql_status": true, + "codeql_time": 47.776015942916274, + "commit": "acf2bc844eef9d0789bfc6ed2951881e6401d9b2", + "commits": 57, + "contributors": 2, + "difficulty": "easy", + "difficulty_code_lines": 825, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 825, + "difficulty_runtime_deps": 6, + "difficulty_score": 1.761551988564182, + "difficulty_test_code_lines": 0, + "full_name": "kpcyrd/rshijack", + "github_stars": 541, + "input_codeql_db": "rust_codeql/kpcyrd__rshijack", + "language": "rs", + "pb_match": [ + { + "pb_fullname": "Drew-Alleman/DataSurgeon", + "rank": 973, + "similarity": 0.4674012064933777 + }, + { + "pb_fullname": "orf/gping", + "rank": 732, + "similarity": 0.4506336450576782 + }, + { + "pb_fullname": "ogham/dog", + "rank": 428, + "similarity": 0.4337601065635681 + }, + { + "pb_fullname": "Isona/dirble", + "rank": 573, + "similarity": 0.46369680762290955 + }, + { + "pb_fullname": "quinn-rs/quinn", + "rank": 909, + "similarity": 0.43185165524482727 + }, + { + "pb_fullname": "ekzhang/bore", + "rank": 91, + "similarity": 0.5756479501724243 + }, + { + "pb_fullname": "agourlay/zip-password-finder", + "rank": 709, + "similarity": 0.46734580397605896 + } + ], + "repo_age": 8.45, + "repo_path": "rust/kpcyrd__rshijack", + "rust_channel": "stable", + "rust_edition": "2021", + "rust_release_date": "2021-10-21", + "rust_version": "1.56.0", + "rust_version_source": "edition", + "source": "commit:acf2bc844eef9d0789bfc6ed2951881e6401d9b2", + "status": "done", + "url": "https://github.com/kpcyrd/rshijack" + }, + "instance_id": "kpcyrd__rshijack.acf2bc8", + "language": "rust", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 4, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "kpcyrd/rshijack" +} diff --git a/kpcyrd--rshijack.acf2bc8/tests/test.sh b/kpcyrd--rshijack.acf2bc8/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kpcyrd--rshijack.acf2bc8/tests/workspace.tar.gz b/kpcyrd--rshijack.acf2bc8/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2276b07fa3a292f1737876e610feb3240fb1634e --- /dev/null +++ b/kpcyrd--rshijack.acf2bc8/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5d8b32cc65250ec494196f05e06786f40ce0233f1671a7a54c1c90637b07973 +size 15929 diff --git a/kreuzwerker--envplate.ec00ede/environment/Dockerfile b/kreuzwerker--envplate.ec00ede/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6f371332b0892136e00733449b81644d11444adf --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/environment/Dockerfile @@ -0,0 +1,58 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kreuzwerker--envplate.ec00ede/environment/download.sh b/kreuzwerker--envplate.ec00ede/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..50c7ae909b757b6a965c4c50b07bfb968a9339fd --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/environment/download.sh @@ -0,0 +1,638 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=local +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kreuzwerker/envplate + +go 1.22 + +require ( + github.com/joho/godotenv v1.5.1 + github.com/spf13/cobra v1.6.1 + github.com/stretchr/testify v1.8.1 + github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af + github.com/yawn/envmap v0.0.0-20160813152305-a78254303070 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= +github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= +github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= +github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= +github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/joho/godotenv v0.0.0-20150907010228-4ed13390c0ac h1:wF2VgtpbaLqhBHV9FxVWzgzgv8VcCjZ66Bl/+F6cpT0= +github.com/joho/godotenv v0.0.0-20150907010228-4ed13390c0ac/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= +github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= +github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c h1:P6XGcuPTigoHf4TSu+3D/7QOQ1MbL6alNwrGhcW7sKw= +github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c/go.mod h1:YnNlZP7l4MhyGQ4CBRwv6ohZTPrUJJZtEv4ZgADkbs4= +github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw= +github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= +github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA= +github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= +github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af h1:eV7i4++vdsO+jWDa/0Us8EE4GZW5XFpYMuUAICYNBps= +github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af/go.mod h1:dvhlbINDXiDEf/Cwinko7RWc1cTpvkn5eR9HhaAEyNQ= +github.com/yawn/envmap v0.0.0-20151212180552-45241142781e h1:gzdo+jflkb/eKuvM3bvVI4TJ+kOBHNrJaccmCGIl4rM= +github.com/yawn/envmap v0.0.0-20151212180552-45241142781e/go.mod h1:n36oviu0t81CF3cW9sdxQzKQ10R9FaiQVmCT9Puslt8= +github.com/yawn/envmap v0.0.0-20160813152305-a78254303070 h1:kzDDpNOIQ/Ob/vdTWAmJ6k3NKDvJEy/CGdR6rSF2Emg= +github.com/yawn/envmap v0.0.0-20160813152305-a78254303070/go.mod h1:n36oviu0t81CF3cW9sdxQzKQ10R9FaiQVmCT9Puslt8= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= +go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= +go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= +golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +PROGRAMGYM_GO_SUM_EOF +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kreuzwerker--envplate.ec00ede/environment/executable b/kreuzwerker--envplate.ec00ede/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..020cc6526680ac7d51a76d5123d3a0921af01c3c --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0089eb828f5c39ed427ef8f84a4ad030271740fe1885e1b4f50e6bc1c136b388 +size 6209144 diff --git a/kreuzwerker--envplate.ec00ede/environment/programgym-go.tar.gz b/kreuzwerker--envplate.ec00ede/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kreuzwerker--envplate.ec00ede/environment/workspace.tar.gz b/kreuzwerker--envplate.ec00ede/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e9fbdaa4d80312936280046a88fad0df75e480e8 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:555fbc8be0bd64d9eff03ce8e82177436ff93c757ef5f3ecdded279c6dde91ac +size 2394 diff --git a/kreuzwerker--envplate.ec00ede/instruction.md b/kreuzwerker--envplate.ec00ede/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kreuzwerker--envplate.ec00ede/solution/solve.sh b/kreuzwerker--envplate.ec00ede/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kreuzwerker--envplate.ec00ede/task.toml b/kreuzwerker--envplate.ec00ede/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2f09e60c3e82b3f9613ae2d48e929212db2543a1 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kreuzwerker--envplate.ec00ede" +description = "Synthetic ProgramGym cleanroom reconstruction task for kreuzwerker/envplate" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kreuzwerker__envplate.ec00ede" +repository = "kreuzwerker/envplate" +commit = "ec00ede3ca03c6bbbe0412bf4b84eacdcdabba11" +language = "go" +difficulty = "unknown" +difficulty_score = 0.0 +test_branches = 5 +test_count = 405 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kreuzwerker--envplate.ec00ede/tests/Dockerfile b/kreuzwerker--envplate.ec00ede/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..bd5f12bacd787ef39a90a560bc0dec968dcdb06e --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_01.tar.gz b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..66fc55327124055680f575dfa7eaf4630405fc10 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:20660151a64457fe73a83d88f3272e6338b294712c1ee5dfca60dc1d7b08b842 +size 19614 diff --git a/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_02.tar.gz b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..64ce58ea01e0bc2a587aab27359b0519a4e61ce3 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4a0e02a91da24a1fec629b0137d894e8dbe2b954213549f2ae8ab53127d77de6 +size 14995 diff --git a/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_03.tar.gz b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0c715be3bfdd1823d6f175e3e90c62e51aff6a3f --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b338243b715dc7bc7a92e5d88754622393345c6c77a0567f95cbc84e5410bd8 +size 8550 diff --git a/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_04.tar.gz b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..00cd184611b233abbdbd275be5236c3f2a6d6bb2 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:445dfcff498b5c4093a4ed0ea339644ab4a7adfa12949b66532caaecfe9b7451 +size 16004 diff --git a/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_upstream.tar.gz b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..40a8a61a261e30d21a1579d1af79c71c35798d93 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:111ff925f477909f7189edc2b11b980e9663628990046040fb69e5cb036282bd +size 5306 diff --git a/kreuzwerker--envplate.ec00ede/tests/download.sh b/kreuzwerker--envplate.ec00ede/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..50c7ae909b757b6a965c4c50b07bfb968a9339fd --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/download.sh @@ -0,0 +1,638 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=local +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kreuzwerker/envplate + +go 1.22 + +require ( + github.com/joho/godotenv v1.5.1 + github.com/spf13/cobra v1.6.1 + github.com/stretchr/testify v1.8.1 + github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af + github.com/yawn/envmap v0.0.0-20160813152305-a78254303070 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= +github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= +github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= +github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= +github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/joho/godotenv v0.0.0-20150907010228-4ed13390c0ac h1:wF2VgtpbaLqhBHV9FxVWzgzgv8VcCjZ66Bl/+F6cpT0= +github.com/joho/godotenv v0.0.0-20150907010228-4ed13390c0ac/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= +github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= +github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c h1:P6XGcuPTigoHf4TSu+3D/7QOQ1MbL6alNwrGhcW7sKw= +github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c/go.mod h1:YnNlZP7l4MhyGQ4CBRwv6ohZTPrUJJZtEv4ZgADkbs4= +github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw= +github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= +github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA= +github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= +github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af h1:eV7i4++vdsO+jWDa/0Us8EE4GZW5XFpYMuUAICYNBps= +github.com/yawn/doubledash v0.0.0-20151212175516-fd8a81db93af/go.mod h1:dvhlbINDXiDEf/Cwinko7RWc1cTpvkn5eR9HhaAEyNQ= +github.com/yawn/envmap v0.0.0-20151212180552-45241142781e h1:gzdo+jflkb/eKuvM3bvVI4TJ+kOBHNrJaccmCGIl4rM= +github.com/yawn/envmap v0.0.0-20151212180552-45241142781e/go.mod h1:n36oviu0t81CF3cW9sdxQzKQ10R9FaiQVmCT9Puslt8= +github.com/yawn/envmap v0.0.0-20160813152305-a78254303070 h1:kzDDpNOIQ/Ob/vdTWAmJ6k3NKDvJEy/CGdR6rSF2Emg= +github.com/yawn/envmap v0.0.0-20160813152305-a78254303070/go.mod h1:n36oviu0t81CF3cW9sdxQzKQ10R9FaiQVmCT9Puslt8= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= +go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= +go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= +golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +PROGRAMGYM_GO_SUM_EOF +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kreuzwerker--envplate.ec00ede/tests/executable b/kreuzwerker--envplate.ec00ede/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..020cc6526680ac7d51a76d5123d3a0921af01c3c --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0089eb828f5c39ed427ef8f84a4ad030271740fe1885e1b4f50e6bc1c136b388 +size 6209144 diff --git a/kreuzwerker--envplate.ec00ede/tests/programgym-go.tar.gz b/kreuzwerker--envplate.ec00ede/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kreuzwerker--envplate.ec00ede/tests/programgym_evaluator.py b/kreuzwerker--envplate.ec00ede/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kreuzwerker--envplate.ec00ede/tests/programgym_task.json b/kreuzwerker--envplate.ec00ede/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..2d9aa39e0cb92c4e403bc3e185d675c8bd21abb7 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/programgym_task.json @@ -0,0 +1,559 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_backup.test_backup_creates_bak_with_original", + "eval.tests.test_backup.test_backup_long_flag", + "eval.tests.test_backup.test_backup_mode_preserved_on_backup", + "eval.tests.test_backup.test_backup_preserves_original_until_overwritten", + "eval.tests.test_backup.test_no_backup_without_flag", + "eval.tests.test_behavior_depth.test_charset_converts_substituted_value_not_literal_text", + "eval.tests.test_behavior_depth.test_charset_encodes_default_substituted_value", + "eval.tests.test_behavior_depth.test_charset_escaped_reference_kept_literal_not_charset_converted", + "eval.tests.test_behavior_depth.test_clean_inline_success_emits_no_output", + "eval.tests.test_behavior_depth.test_dry_run_success_emits_nothing_on_stderr", + "eval.tests.test_behavior_depth.test_empty_declared_value_substitutes_empty", + "eval.tests.test_behavior_depth.test_mixed_matching_and_nonmatching_globs_succeed", + "eval.tests.test_behavior_depth.test_multi_glob_error_commits_earlier_file_but_not_later", + "eval.tests.test_behavior_depth.test_no_charset_passthrough_literal_unicode", + "eval.tests.test_behavior_depth.test_parse_error_with_backup_does_not_create_backup", + "eval.tests.test_behavior_depth.test_strict_with_empty_declared_value_ok", + "eval.tests.test_behavior_depth.test_undeclared_var_prevents_whole_file_write", + "eval.tests.test_behavior_depth.test_undefined_empty_default_substitutes_empty", + "eval.tests.test_charset.test_charset_accepts_lowercase_utf8_names[--charset]", + "eval.tests.test_charset.test_charset_accepts_lowercase_utf8_names[-c]", + "eval.tests.test_charset.test_charset_ascii_identity_for_ascii", + "eval.tests.test_charset.test_charset_default_is_utf8_passthrough", + "eval.tests.test_charset.test_charset_empty_value_is_utf8", + "eval.tests.test_charset.test_charset_iso8859_1_encodes_value_bytes", + "eval.tests.test_charset.test_invalid_charset_fails", + "eval.tests.test_charset.test_short_charset_wired_in", + "eval.tests.test_cli_flags.test_boolean_flag_true_without_value_ok[--backup]", + "eval.tests.test_cli_flags.test_boolean_flag_true_without_value_ok[--strict]", + "eval.tests.test_cli_flags.test_flag_after_positional_glob_still_parsed", + "eval.tests.test_cli_flags.test_flag_value_eaten_by_trailing_dash", + "eval.tests.test_cli_flags.test_invalid_backup_boolean_value_rejected", + "eval.tests.test_cli_flags.test_invalid_dryrun_boolean_value_rejected", + "eval.tests.test_cli_flags.test_invalid_strict_boolean_value_rejected", + "eval.tests.test_cli_flags.test_invalid_verbose_boolean_value_rejected", + "eval.tests.test_cli_flags.test_long_charset_missing_argument", + "eval.tests.test_cli_flags.test_short_charset_missing_argument", + "eval.tests.test_cli_flags.test_unknown_long_flag_rejected", + "eval.tests.test_cli_flags.test_unknown_short_flag_rejected", + "eval.tests.test_cli_help.test_help_describes_each_flag[-b-Create a backup file when using inline mode]", + "eval.tests.test_cli_help.test_help_describes_each_flag[-c-Output charset]", + "eval.tests.test_cli_help.test_help_describes_each_flag[-d-Dry-run - output templates to stdout instead of inline replacement]", + "eval.tests.test_cli_help.test_help_describes_each_flag[-s-Strict-mode - fail when falling back on defaults]", + "eval.tests.test_cli_help.test_help_describes_each_flag[-v-Verbose logging]", + "eval.tests.test_cli_help.test_help_does_not_require_a_file", + "eval.tests.test_cli_help.test_help_exits_zero_and_describes_command[--help]", + "eval.tests.test_cli_help.test_help_exits_zero_and_describes_command[-h]", + "eval.tests.test_cli_help.test_help_ignores_positional_glob", + "eval.tests.test_cli_help.test_help_lists_all_flags", + "eval.tests.test_dryrun.test_dry_run_blocks_exec", + "eval.tests.test_dryrun.test_dry_run_leaves_input_unchanged", + "eval.tests.test_dryrun.test_dry_run_long_flag", + "eval.tests.test_dryrun.test_dry_run_prints_expanded_stdout", + "eval.tests.test_dryrun.test_dry_run_prints_multiline_preserved", + "eval.tests.test_dryrun.test_dry_run_short_flag", + "eval.tests.test_dryrun.test_dry_run_with_escaped_reference", + "eval.tests.test_dryrun.test_dry_run_with_undeclared_no_default_fails", + "eval.tests.test_escaping.test_complex_inline_lines[A=${E} ${F:-z}-A=x z]", + "eval.tests.test_escaping.test_complex_inline_lines[A=${E}${F:-y}end-A=xyend]", + "eval.tests.test_escaping.test_complex_inline_lines[A=${}/empty-key-A=${}/empty-key]", + "eval.tests.test_escaping.test_double_backslash_activates", + "eval.tests.test_escaping.test_escape_keeps_reference_literal", + "eval.tests.test_escaping.test_escape_with_default_stays_whole_literal", + "eval.tests.test_escaping.test_plain_reference_still_expands", + "eval.tests.test_escaping.test_quad_backslash_activates_with_two_leaders", + "eval.tests.test_escaping.test_reference_not_matching_pattern_left_alone", + "eval.tests.test_escaping.test_triple_backslash_escapes", + "eval.tests.test_exec.test_exec_args_after_dash_forwarded_not_parsed", + "eval.tests.test_exec.test_exec_child_exit_status_propagates", + "eval.tests.test_exec.test_exec_child_zero_exit", + "eval.tests.test_exec.test_exec_command_produces_marker_file_side_effect", + "eval.tests.test_exec.test_exec_propagates_child_stdout_and_env", + "eval.tests.test_exec.test_exec_replaces_file_then_runs_command", + "eval.tests.test_exec.test_exec_unresolvable_program_fails", + "eval.tests.test_exec.test_exec_uses_latest_dash_only_once", + "eval.tests.test_exec.test_exec_with_globs_and_no_dash_does_not_exec", + "eval.tests.test_flag_interplay.test_bundled_short_boolean_flags_vbd", + "eval.tests.test_flag_interplay.test_dry_run_with_backup_creates_no_backup_file", + "eval.tests.test_flag_interplay.test_help_flag_after_dash_is_not_help", + "eval.tests.test_flag_interplay.test_inline_charset_rewrites_file_bytes", + "eval.tests.test_flag_interplay.test_inline_charset_with_backup_keeps_original_template", + "eval.tests.test_flag_interplay.test_parse_error_takes_precedence_over_help[help_first]", + "eval.tests.test_flag_interplay.test_parse_error_takes_precedence_over_help[invalid_first]", + "eval.tests.test_inline_replace.test_inline_directory_only_glob_fails", + "eval.tests.test_inline_replace.test_inline_env_value_beats_default", + "eval.tests.test_inline_replace.test_inline_files_skipped_directories_but_process_files", + "eval.tests.test_inline_replace.test_inline_mixed_glob_and_good_glob_succeeds", + "eval.tests.test_inline_replace.test_inline_multiple_files_all_replaced", + "eval.tests.test_inline_replace.test_inline_no_match_glob_fails", + "eval.tests.test_inline_replace.test_inline_no_positional_glob_fails", + "eval.tests.test_inline_replace.test_inline_replacement_variants[${PORT:-8080}-8080]", + "eval.tests.test_inline_replace.test_inline_replacement_variants[${URL:-http://host/a?b=1}-http://host/a?b=1]", + "eval.tests.test_inline_replace.test_inline_replacement_variants[host is ${HOST}; ok-host is h1; ok]", + "eval.tests.test_inline_replace.test_inline_replacement_variants[x=${A} y=${B}-x=1 y=2]", + "eval.tests.test_inline_replace.test_inline_replaces_single_variable", + "eval.tests.test_inline_replace.test_inline_undeclared_without_default_fails", + "eval.tests.test_inline_replace.test_inline_uses_default_when_undeclared", + "eval.tests.test_main_wiring.test_all_equals_combined_verbose_charset_dry_run", + "eval.tests.test_main_wiring.test_backup_empty_boolean_value_rejected", + "eval.tests.test_main_wiring.test_backup_equals_false_does_not_backup", + "eval.tests.test_main_wiring.test_backup_equals_true_backups", + "eval.tests.test_main_wiring.test_backup_short_equals_false_does_not_backup", + "eval.tests.test_main_wiring.test_charset_equals_flag_dry_run_bytes", + "eval.tests.test_main_wiring.test_charset_equals_flag_inline_bytes", + "eval.tests.test_main_wiring.test_dry_run_equals_true_prints_stdout", + "eval.tests.test_main_wiring.test_empty_declared_value_beats_default_non_strict", + "eval.tests.test_main_wiring.test_exec_child_shell_receives_ep_env", + "eval.tests.test_main_wiring.test_exec_directory_fails_permission", + "eval.tests.test_main_wiring.test_exec_replaces_file_before_child_sees_it", + "eval.tests.test_main_wiring.test_exec_requires_double_dash_before_command", + "eval.tests.test_main_wiring.test_verbose_equals_true_emits_debug", + "eval.tests.test_main_wiring.test_version_flag_is_unknown", + "eval.tests.test_strict.test_strict_failure_overrides_subsequent_files", + "eval.tests.test_strict.test_strict_leaves_file_untouched_on_failure", + "eval.tests.test_strict.test_strict_long_flag", + "eval.tests.test_strict.test_strict_rejects_default_fallback", + "eval.tests.test_strict.test_strict_with_declared_variable_ignores_default", + "eval.tests.test_strict.test_strict_with_declared_variable_succeeds", + "eval.tests.test_verbose.test_long_verbose_emits_debug", + "eval.tests.test_verbose.test_non_verbose_suppresses_debug", + "eval.tests.test_verbose.test_verbose_dry_run_reports_dryrun", + "eval.tests.test_verbose.test_verbose_emits_debug_to_stderr", + "eval.tests.test_verbose.test_verbose_flag_position_after_glob", + "eval.tests.test_verbose.test_verbose_record_uses_default" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_backup.test_backup_dryrun_does_not_create_backup", + "eval.tests.test_backup.test_backup_file_created_with_original", + "eval.tests.test_backup.test_backup_live_file_expanded", + "eval.tests.test_backup.test_backup_multiple_files_each_backed_up", + "eval.tests.test_backup.test_backup_preserves_file_mode", + "eval.tests.test_backup.test_error_prevents_backup_creation", + "eval.tests.test_backup.test_inline_preserves_live_file_mode", + "eval.tests.test_backup.test_no_backup_without_flag", + "eval.tests.test_charset.test_ascii_only_text_unchanged_by_charset", + "eval.tests.test_charset.test_charset_applies_to_default_value", + "eval.tests.test_charset.test_charset_noop_for_empty_string", + "eval.tests.test_charset.test_dryrun_charset_output_bytes", + "eval.tests.test_charset.test_inline_iso8859_1_encodes_latin1", + "eval.tests.test_charset.test_inline_windows_1252_encodes", + "eval.tests.test_charset.test_no_charset_flag_keeps_utf8", + "eval.tests.test_cli.test_directory_in_glob_skipped_and_files_expanded", + "eval.tests.test_cli.test_glob_matches_multiple_files_in_order", + "eval.tests.test_cli.test_glob_only_directory_is_zero_files", + "eval.tests.test_cli.test_h_short_flag_prints_usage", + "eval.tests.test_cli.test_help_flag_prints_usage_exit_zero", + "eval.tests.test_cli.test_help_lists_all_flags", + "eval.tests.test_cli.test_non_verbose_suppresses_debug_logs", + "eval.tests.test_cli.test_relative_file_path_resolved_from_cwd", + "eval.tests.test_cli.test_verbose_emits_debug_logs_to_stderr", + "eval.tests.test_cli.test_verbose_logs_default_use", + "eval.tests.test_cli.test_verbose_logs_reference_expansion", + "eval.tests.test_coverage_and_edges.test_backup_dir_collision_does_not_write_other_files", + "eval.tests.test_coverage_and_edges.test_backup_fails_when_bak_path_is_directory", + "eval.tests.test_coverage_and_edges.test_backup_first_file_persists_when_later_file_errors", + "eval.tests.test_coverage_and_edges.test_charset_does_not_convert_literal_file_text", + "eval.tests.test_coverage_and_edges.test_charset_lossily_replaces_unrepresentable_value", + "eval.tests.test_coverage_and_edges.test_combined_backup_charset_defined_var", + "eval.tests.test_coverage_and_edges.test_combined_strict_backup_defined_no_error", + "eval.tests.test_coverage_and_edges.test_default_containing_closing_brace_runs_out_to_last", + "eval.tests.test_coverage_and_edges.test_default_containing_separator_preserved", + "eval.tests.test_coverage_and_edges.test_empty_config_file_processed_cleanly", + "eval.tests.test_coverage_and_edges.test_empty_key_braces_left_literal", + "eval.tests.test_coverage_and_edges.test_escaped_ref_bad_charset_conversion_error", + "eval.tests.test_coverage_and_edges.test_escaped_reference_survives_successful_charset_conversion", + "eval.tests.test_coverage_and_edges.test_malformed_glob_produces_no_stdout", + "eval.tests.test_coverage_and_edges.test_no_recursive_rescan_of_substituted_value", + "eval.tests.test_coverage_and_edges.test_strict_dry_run_refuses_default_fallback", + "eval.tests.test_coverage_and_edges.test_unclosed_reference_left_literal", + "eval.tests.test_coverage_and_edges.test_unknown_long_flag_error", + "eval.tests.test_coverage_and_edges.test_unknown_short_flag_error", + "eval.tests.test_coverage_and_edges.test_verbose_logs_escaped_substitution", + "eval.tests.test_coverage_and_edges.test_verbose_strict_dry_run_defined_var_succeeds", + "eval.tests.test_dryrun.test_dry_run_does_not_modify_file", + "eval.tests.test_dryrun.test_dry_run_escaped_sequence_preserved", + "eval.tests.test_dryrun.test_dry_run_exit_zero", + "eval.tests.test_dryrun.test_dry_run_multiple_vars_all_expanded", + "eval.tests.test_dryrun.test_dry_run_preserves_literal_lines", + "eval.tests.test_dryrun.test_dry_run_writes_expanded_to_stdout", + "eval.tests.test_dryrun.test_dry_run_zero_files_still_errors", + "eval.tests.test_errors.test_empty_string_charset_is_noop", + "eval.tests.test_errors.test_error_first_file_aborts_without_processing_rest", + "eval.tests.test_errors.test_invalid_charset_error", + "eval.tests.test_errors.test_invalid_charset_message_mentions_charset", + "eval.tests.test_errors.test_malformed_glob_error", + "eval.tests.test_errors.test_no_arguments_zero_globs_error", + "eval.tests.test_errors.test_non_strict_allows_default", + "eval.tests.test_errors.test_strict_file_unchanged_on_refusal", + "eval.tests.test_errors.test_strict_ok_when_variable_defined", + "eval.tests.test_errors.test_strict_refuses_default_fallback", + "eval.tests.test_errors.test_strict_undeclared_no_default_still_errors", + "eval.tests.test_errors.test_undeclared_no_default_error_exit", + "eval.tests.test_errors.test_undeclared_no_default_file_unchanged", + "eval.tests.test_errors.test_zero_files_matched_error", + "eval.tests.test_errors.test_zero_files_message_lists_globs", + "eval.tests.test_escaping.test_backslash_run_escaping[bs0_expanded]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs1_escaped_literal]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs2_expanded_half_to_one]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs3_escaped_one_literal_slash]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs4_expanded_half_to_two]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs5_escaped_two_literal_slashes]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs6_expanded_half_to_three]", + "eval.tests.test_escaping.test_backslash_run_escaping[bs7_escaped_three_literal_slashes]", + "eval.tests.test_escaping.test_backslash_run_with_default[esc_default_bs1]", + "eval.tests.test_escaping.test_backslash_run_with_default[esc_default_bs3]", + "eval.tests.test_escaping.test_backslash_run_with_default[exp_default_bs0]", + "eval.tests.test_escaping.test_backslash_run_with_default[exp_default_bs2]", + "eval.tests.test_escaping.test_backslashes_without_reference_unchanged", + "eval.tests.test_escaping.test_simple_single_backslash_no_match", + "eval.tests.test_escaping.test_unescaped_reference_not_affected_by_escape", + "eval.tests.test_exec.test_exec_absence_just_exits", + "eval.tests.test_exec.test_exec_dry_run_does_not_exec", + "eval.tests.test_exec.test_exec_forward_exit_code", + "eval.tests.test_exec.test_exec_inherits_expanded_environment", + "eval.tests.test_exec.test_exec_inner_command_with_args", + "eval.tests.test_exec.test_exec_missing_binary_errors", + "eval.tests.test_exec.test_exec_only_with_no_globs_fails_earlier", + "eval.tests.test_exec.test_exec_runs_command_after_parse", + "eval.tests.test_exec.test_exec_still_applies_file_substitutions_first", + "eval.tests.test_expansion.test_default_usd_for_empty_but_present_default_key", + "eval.tests.test_expansion.test_default_used_when_unset", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[-1]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[a;b${c}]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[empty]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[http://example.com/x?y=1&z=2]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[under_score]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[with space]", + "eval.tests.test_expansion.test_default_values_preserved_verbatim[with:colon]", + "eval.tests.test_expansion.test_defined_var_used_across_separate_refs", + "eval.tests.test_expansion.test_empty_default_means_empty_not_error", + "eval.tests.test_expansion.test_empty_string_env_treated_as_defined_with_default", + "eval.tests.test_expansion.test_empty_string_env_treated_as_defined_without_default", + "eval.tests.test_expansion.test_expansion_without_trailing_newline", + "eval.tests.test_expansion.test_key_with_digits_and_underscore", + "eval.tests.test_expansion.test_multiline_file_with_mixed_refs", + "eval.tests.test_expansion.test_multiple_vars_same_file_inline", + "eval.tests.test_expansion.test_no_references_leaves_file_unchanged", + "eval.tests.test_expansion.test_real_value_wins_over_default", + "eval.tests.test_expansion.test_references_adjacent_without_separator", + "eval.tests.test_expansion.test_single_var_inline_expansion", + "eval.tests.test_expansion.test_value_appears_multiple_times", + "eval.tests.test_expansion.test_variable_value_is_literal[123]", + "eval.tests.test_expansion.test_variable_value_is_literal[dash-value]", + "eval.tests.test_expansion.test_variable_value_is_literal[line]", + "eval.tests.test_expansion.test_variable_value_is_literal[plain]", + "eval.tests.test_expansion.test_variable_value_is_literal[slash/sep]", + "eval.tests.test_expansion.test_variable_value_is_literal[with space]", + "eval.tests.test_expansion.test_variable_value_is_literal[with=equals]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_logger.test_backup_mode_creates_bak_and_logs_creating_backup_verbose", + "eval.tests.test_logger.test_backup_mode_without_verbose_creates_bak_but_no_debug", + "eval.tests.test_logger.test_debug_default_emitted_when_var_absent_verbose", + "eval.tests.test_logger.test_debug_default_only_reported_when_var_absent", + "eval.tests.test_logger.test_debug_emitted_with_verbose_flag_exact_lines", + "eval.tests.test_logger.test_debug_expansion_line_carries_key_and_value_exact", + "eval.tests.test_logger.test_debug_long_verbose_flag_equivalent_to_short", + "eval.tests.test_logger.test_debug_parsing_line_names_the_file_exactly", + "eval.tests.test_logger.test_debug_suppressed_without_verbose_emits_nothing", + "eval.tests.test_logger.test_error_format_args_interpolated_exact_message", + "eval.tests.test_logger.test_error_glob_matching_only_directory_is_zero_files", + "eval.tests.test_logger.test_error_invalid_charset_routes_to_stderr_exact_message", + "eval.tests.test_logger.test_error_line_has_timestamp_and_exact_message", + "eval.tests.test_logger.test_error_missing_var_names_the_file_in_both_lines", + "eval.tests.test_logger.test_error_missing_var_no_default_exit_code_1", + "eval.tests.test_logger.test_error_strict_mode_rejects_default_fallback_exact", + "eval.tests.test_logger.test_error_zero_files_matched_exit_1[no_args]", + "eval.tests.test_logger.test_error_zero_files_matched_exit_1[unmatched_glob_a]", + "eval.tests.test_logger.test_error_zero_files_matched_exit_1[unmatched_glob_b]", + "eval.tests.test_logger.test_escaped_even_backslashes_expand_removing_half", + "eval.tests.test_logger.test_escaped_sequence_debug_and_literal_output", + "eval.tests.test_logger.test_escaped_sequence_inline_rewrites_file_untouched", + "eval.tests.test_logger.test_help_flag_matches_golden_output", + "eval.tests.test_logger.test_no_backup_mode_leaves_no_bak_file", + "eval.tests.test_logger.test_raw_default_value_substitution_in_dry_run", + "eval.tests.test_logger.test_raw_glob_wildcard_matches_in_sorted_order", + "eval.tests.test_logger.test_raw_multiple_files_emit_in_glob_argument_order", + "eval.tests.test_logger.test_raw_output_exact_bytes_on_stdout[empty]", + "eval.tests.test_logger.test_raw_output_exact_bytes_on_stdout[no_trailing_newline]", + "eval.tests.test_logger.test_raw_output_exact_bytes_on_stdout[single_line_newline]", + "eval.tests.test_logger.test_raw_output_exact_bytes_on_stdout[two_lines]", + "eval.tests.test_logger.test_raw_passthrough_of_mid_percent_exact_bytes", + "eval.tests.test_logger.test_raw_passthrough_of_trailing_percent_exact_bytes", + "eval.tests.test_logger.test_raw_routes_to_stdout_while_debug_logs_go_to_stderr", + "eval.tests.test_logger.test_raw_single_file_does_not_append_newline_when_absent", + "eval.tests.test_logger.test_raw_stdout_is_exactly_expanded_payload", + "eval.tests.test_logger.test_short_help_flag_matches_golden_output", + "eval.tests.test_logger.test_valid_utf8_charset_roundtrip_raw_stdout", + "eval.tests.test_logger.test_verbose_and_error_messages_coexist_on_stderr", + "eval.tests.test_logger.test_verbose_debug_dryrun_stderr_is_strictly_debug", + "eval.tests.test_logger.test_verbose_debug_proceeds_to_raw_dryrun_output" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_backup_binary_and_cli_surface.test_help_documents_backup_flag_surface", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_backup_binary_and_cli_surface.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backup_binary_and_cli_surface.test_short_help_flag_documents_backup_surface", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_backup_binary_and_cli_surface.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_backup_apply_directory_skip.test_backup_explicit_directory_arg_produces_zero_matched_error", + "eval.tests.test_backup_apply_directory_skip.test_backup_glob_skips_directory_but_backs_up_files", + "eval.tests.test_backup_apply_directory_skip.test_backup_symlink_to_directory_arg_produces_zero_matched_error", + "eval.tests.test_backup_apply_directory_skip.test_backup_with_no_args_reports_zero_matched_empty_globs", + "eval.tests.test_backup_binary_and_cli_surface.test_backup_binary_only_suffix_bytes_kept_in_both", + "eval.tests.test_backup_binary_and_cli_surface.test_backup_preserves_binary_nul_and_nonutf8_bytes", + "eval.tests.test_backup_binary_and_cli_surface.test_help_documents_backup_flag_surface", + "eval.tests.test_backup_binary_and_cli_surface.test_short_help_flag_documents_backup_surface", + "eval.tests.test_backup_binary_and_cli_surface.test_unknown_flag_aborts_before_any_backup_side_effect", + "eval.tests.test_backup_content_and_mode_extra.test_backup_expands_unicode_environment_value", + "eval.tests.test_backup_content_and_mode_extra.test_backup_multiline_template_expands_all_lines", + "eval.tests.test_backup_content_and_mode_extra.test_backup_of_file_with_only_trailing_newline_content", + "eval.tests.test_backup_content_and_mode_extra.test_backup_preserves_crlf_line_endings", + "eval.tests.test_backup_content_and_mode_extra.test_backup_preserves_protection_bit_patterns[146]", + "eval.tests.test_backup_content_and_mode_extra.test_backup_preserves_protection_bit_patterns[438]", + "eval.tests.test_backup_content_and_mode_extra.test_backup_preserves_protection_bit_patterns[511]", + "eval.tests.test_backup_content_and_mode_extra.test_backup_preserves_protection_bit_patterns[73]", + "eval.tests.test_backup_content_and_mode_extra.test_backup_repeated_environment_variable_expands_each_occurrence", + "eval.tests.test_backup_content_and_mode_extra.test_backup_set_environment_variable_wins_over_default", + "eval.tests.test_backup_content_and_mode_extra.test_setuid_and_setgid_mode_combined_preserved", + "eval.tests.test_backup_content_and_mode_extra.test_sticky_bit_mode_preserved", + "eval.tests.test_backup_content_variants.test_backup_absolute_source_path_from_other_cwd", + "eval.tests.test_backup_content_variants.test_backup_env_value_dollar_not_reexpanded", + "eval.tests.test_backup_content_variants.test_backup_env_value_with_equals_sign", + "eval.tests.test_backup_content_variants.test_backup_env_value_with_surrounding_spaces", + "eval.tests.test_backup_content_variants.test_backup_expands_empty_string_env_value", + "eval.tests.test_backup_content_variants.test_backup_in_nested_subdirectory_sits_next_to_source", + "eval.tests.test_backup_content_variants.test_backup_multiple_trailing_blank_lines_preserved", + "eval.tests.test_backup_content_variants.test_backup_suffix_on_file_named_bak", + "eval.tests.test_backup_content_variants.test_backup_whitespace_only_file_is_byte_exact", + "eval.tests.test_backup_content_variants.test_backup_without_trailing_newline_is_byte_exact", + "eval.tests.test_backup_creation.test_backup_contains_original_preexpansion_content", + "eval.tests.test_backup_creation.test_backup_created_alongside_source_with_bak_suffix", + "eval.tests.test_backup_creation.test_backup_dry_run_order_backup_only_in_inline_mode", + "eval.tests.test_backup_creation.test_backup_glob_creates_one_backup_per_matching_file", + "eval.tests.test_backup_creation.test_backup_of_empty_file_is_empty", + "eval.tests.test_backup_creation.test_backup_of_file_with_no_references_is_copy_of_original", + "eval.tests.test_backup_creation.test_backup_of_file_with_only_escaped_references", + "eval.tests.test_backup_creation.test_backup_preserves_default_value_expansion", + "eval.tests.test_backup_creation.test_dry_run_creates_no_backup", + "eval.tests.test_backup_creation.test_no_backup_flag_creates_no_bak", + "eval.tests.test_backup_creation.test_rerun_overwrites_previous_backup_with_new_source", + "eval.tests.test_backup_creation_errors.test_backup_directory_collision_leaves_source_unexpanded", + "eval.tests.test_backup_creation_errors.test_backup_directory_collision_mode_unchanged[384]", + "eval.tests.test_backup_creation_errors.test_backup_directory_collision_mode_unchanged[420]", + "eval.tests.test_backup_creation_errors.test_backup_directory_collision_produces_no_backup_file", + "eval.tests.test_backup_creation_errors.test_backup_directory_collision_recovery_on_rerun", + "eval.tests.test_backup_creation_errors.test_backup_error_when_bak_path_is_a_directory", + "eval.tests.test_backup_creation_errors.test_backup_glob_aborts_on_bak_directory_collision", + "eval.tests.test_backup_creation_errors.test_backup_long_flag_directory_collision_reports_same_cause", + "eval.tests.test_backup_edge_cases.test_backup_via_symlink_creates_regular_bak_next_to_link", + "eval.tests.test_backup_edge_cases.test_error_when_glob_matches_no_files", + "eval.tests.test_backup_edge_cases.test_malformed_glob_pattern_errors_without_side_effect[[]", + "eval.tests.test_backup_edge_cases.test_malformed_glob_pattern_errors_without_side_effect[a,b*[]", + "eval.tests.test_backup_edge_cases.test_malformed_glob_pattern_errors_without_side_effect[bad[glob]", + "eval.tests.test_backup_edge_cases.test_malformed_glob_pattern_errors_without_side_effect[{}]", + "eval.tests.test_backup_edge_cases.test_multiple_reruns_backup_reflects_latest_original", + "eval.tests.test_backup_parse_error_abort.test_backup_aborted_by_undeclared_reference_creates_no_bak", + "eval.tests.test_backup_parse_error_abort.test_backup_parse_error_long_flag_also_no_bak[--backup]", + "eval.tests.test_backup_parse_error_abort.test_backup_parse_error_long_flag_also_no_bak[-b]", + "eval.tests.test_backup_parse_error_abort.test_backup_strict_undeclared_default_aborts_and_creates_no_bak", + "eval.tests.test_backup_parse_error_abort.test_backup_undeclared_with_default_still_creates_bak", + "eval.tests.test_backup_path_and_name_variants.test_backup_case_sensitive_filename_keeps_case_in_bak", + "eval.tests.test_backup_path_and_name_variants.test_backup_dot_env_file_gets_dot_env_bak", + "eval.tests.test_backup_path_and_name_variants.test_backup_dot_hidden_file_gets_dot_hidden_bak", + "eval.tests.test_backup_path_and_name_variants.test_backup_filename_with_spaces_gets_spaced_bak", + "eval.tests.test_backup_path_and_name_variants.test_backup_long_flag_multiple_explicit_files_one_bak_each", + "eval.tests.test_backup_path_and_name_variants.test_backup_midname_bak_file_gets_double_suffix", + "eval.tests.test_backup_path_and_name_variants.test_backup_path_with_dotdot_relative_segments_normalizes_bak_location[sub/../sub/n.txt]", + "eval.tests.test_backup_path_and_name_variants.test_backup_path_with_dotdot_relative_segments_normalizes_bak_location[sub/./n.txt]", + "eval.tests.test_backup_path_and_name_variants.test_backup_path_with_dotdot_relative_segments_normalizes_bak_location[sub//n.txt]", + "eval.tests.test_backup_stateful_and_mode.test_backup_glob_processes_earlier_files_then_aborts_on_collision", + "eval.tests.test_backup_stateful_and_mode.test_backup_mode_preserved_for_execute_only_input", + "eval.tests.test_backup_stateful_and_mode.test_backup_mode_preserved_in_subdirectory", + "eval.tests.test_backup_stateful_and_mode.test_backup_of_bak_named_file_preserves_mode", + "eval.tests.test_backup_stateful_and_mode.test_backup_success_then_directory_collision_blocks_reexpansion", + "eval.tests.test_backup_symlink_targets.test_backup_bak_symlink_to_regular_file_mode_applied_to_target", + "eval.tests.test_backup_symlink_targets.test_backup_bak_symlink_to_regular_file_writes_through", + "eval.tests.test_backup_symlink_targets.test_backup_dangling_bak_symlink_aborts_with_exact_enoent", + "eval.tests.test_backup_symlink_targets.test_backup_dangling_bak_symlink_in_subdir_aborts", + "eval.tests.test_backup_symlink_targets.test_backup_dangling_bak_symlink_long_flag_same_error", + "eval.tests.test_backup_verbose_trace.test_nonverbose_backup_emits_no_debug_stderr", + "eval.tests.test_backup_verbose_trace.test_verbose_absolute_path_reflected_in_creating_backup_line", + "eval.tests.test_backup_verbose_trace.test_verbose_backup_emits_creating_backup_debug_line", + "eval.tests.test_backup_verbose_trace.test_verbose_dry_run_backup_logs_no_backup_creation", + "eval.tests.test_backup_verbose_trace.test_verbose_glob_backup_emits_one_creating_backup_per_file", + "eval.tests.test_backup_verbose_trace.test_verbose_long_flag_backup_same_creating_backup_trace", + "eval.tests.test_backup_verbose_trace.test_verbose_without_backup_omits_creating_backup_line", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[384]", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[388]", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[416]", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[436]", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[448]", + "eval.tests.test_filemode_preservation.test_backup_mode_matches_source_mode[488]", + "eval.tests.test_filemode_preservation.test_execute_and_setuid_mode_preserved_on_main_and_backup", + "eval.tests.test_filemode_preservation.test_glob_preserves_distinct_per_file_modes", + "eval.tests.test_filemode_preservation.test_main_and_backup_modes_equal_after_backup", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[292]", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[384]", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[388]", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[420]", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[448]", + "eval.tests.test_filemode_preservation.test_main_file_keeps_original_mode_after_inline_expansion[492]", + "eval.tests.test_filemode_preservation.test_mode_preserved_without_backup_flag", + "eval.tests.test_filemode_preservation.test_readonly_mode_file_rewritten_keeps_readonly_mode", + "eval.tests.test_filemode_preservation.test_setgid_mode_preserved" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_exec.test_doubledash_exec_runs_command_after_processing_files", + "eval.tests.test_exec.test_dry_run_does_not_exec_trailing_command", + "eval.tests.test_modes_and_logging.test_backup_preserves_source_file_mode", + "eval.tests.test_modes_and_logging.test_filemode_twiddle_owned_from_upstream_is_reported", + "eval.tests.test_modes_and_logging.test_no_matching_globs_fails_with_diagnostic", + "eval.tests.test_modes_and_logging.test_verbose_dry_run_emits_debug_and_info_and_raw", + "eval.tests.test_templates.test_abort_on_parse_errors_leaves_file_and_no_backup", + "eval.tests.test_templates.test_dry_run_prints_expanded_template[template1.txt-eval/golden_outputs/template1.parsed.golden]", + "eval.tests.test_templates.test_dry_run_prints_expanded_template[template2.txt-eval/golden_outputs/template2.parsed.golden]", + "eval.tests.test_templates.test_dry_run_prints_expanded_template[template3.txt-eval/golden_outputs/template3.parsed.golden]", + "eval.tests.test_templates.test_full_parse_defaults", + "eval.tests.test_templates.test_full_parse_escapes", + "eval.tests.test_templates.test_full_parse_replaces_inline_and_backs_up", + "eval.tests.test_templates.test_strict_mode_refuses_default_fallback_and_exits1" + ] + } + }, + "commit": "ec00ede3ca03c6bbbe0412bf4b84eacdcdabba11", + "data_source": "synthetic_programgym", + "difficulty": "", + "difficulty_score": null, + "eval_clean_hashes": [ + "0089eb828f5c39ed427ef8f84a4ad030271740fe1885e1b4f50e6bc1c136b388" + ], + "input_record": { + "commit": "ec00ede3ca03c6bbbe0412bf4b84eacdcdabba11", + "commits": 93, + "contributors": 7, + "difficulty": "easy", + "difficulty_code_lines": 417, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 417, + "difficulty_runtime_deps": 11, + "difficulty_score": 1.6993173010213827, + "difficulty_test_code_lines": 504, + "full_name": "kreuzwerker/envplate", + "github_stars": 344, + "input_joern_zip": "go_joern/kreuzwerker__envplate.zip", + "joern_status": true, + "joern_time": 6.472292825812474, + "language": "go", + "pb_match": [ + { + "pb_fullname": "segmentio/chamber", + "rank": 369, + "similarity": 0.5288788080215454 + }, + { + "pb_fullname": "sclevine/yj", + "rank": 157, + "similarity": 0.5289202332496643 + }, + { + "pb_fullname": "mikefarah/yq", + "rank": 599, + "similarity": 0.5242012143135071 + }, + { + "pb_fullname": "guumaster/hostctl", + "rank": 186, + "similarity": 0.49034756422042847 + }, + { + "pb_fullname": "direnv/direnv", + "rank": 99, + "similarity": 0.4749045968055725 + }, + { + "pb_fullname": "JohannesKaufmann/html-to-markdown", + "rank": 996, + "similarity": 0.4644278883934021 + }, + { + "pb_fullname": "gabotechs/dep-tree", + "rank": 913, + "similarity": 0.4953033924102783 + }, + { + "pb_fullname": "FiloSottile/age", + "rank": 684, + "similarity": 0.4615369439125061 + }, + { + "pb_fullname": "skeema/skeema", + "rank": 926, + "similarity": 0.4802325367927551 + }, + { + "pb_fullname": "hairyhenderson/gomplate", + "rank": 34, + "similarity": 0.6098126173019409 + } + ], + "repo_age": 11.72, + "repo_path": "go/kreuzwerker__envplate", + "source": "commit:ec00ede3ca03c6bbbe0412bf4b84eacdcdabba11", + "status": "done", + "url": "https://github.com/kreuzwerker/envplate" + }, + "instance_id": "kreuzwerker__envplate.ec00ede", + "language": "go", + "module_iterations": [], + "repository": "kreuzwerker/envplate" +} diff --git a/kreuzwerker--envplate.ec00ede/tests/test.sh b/kreuzwerker--envplate.ec00ede/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kreuzwerker--envplate.ec00ede/tests/workspace.tar.gz b/kreuzwerker--envplate.ec00ede/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e9fbdaa4d80312936280046a88fad0df75e480e8 --- /dev/null +++ b/kreuzwerker--envplate.ec00ede/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:555fbc8be0bd64d9eff03ce8e82177436ff93c757ef5f3ecdded279c6dde91ac +size 2394 diff --git a/kthohr--optim.5453f48/environment/Dockerfile b/kthohr--optim.5453f48/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..cd042aa1c8902da43f5e168d272841107895d27b --- /dev/null +++ b/kthohr--optim.5453f48/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kthohr--optim.5453f48/environment/docker-compose.yaml b/kthohr--optim.5453f48/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kthohr--optim.5453f48/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kthohr--optim.5453f48/environment/download.sh b/kthohr--optim.5453f48/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..3e38ccab397a0fc95548ecb742b665912a6d4d77 --- /dev/null +++ b/kthohr--optim.5453f48/environment/download.sh @@ -0,0 +1,98 @@ +#!/usr/bin/env bash +################################################################################ +## ProgramGym download.sh -- OptimLib (kthohr/optim) +## +## Networked, standalone stage. Sourced via `source /source_ro/download.sh`. +## It must NOT read any repository file, must NOT compile/test/build, and must +## be safe to re-source (idempotent). +## +## It prepares, for the later offline build.sh: +## * apt system packages: libeigen3-dev (Eigen headers), libblas-dev and +## liblapack-dev (link symbols required by the project's `make` target). +## * autodiff v1.1.2 headers -> /usr/local/include/autodiff +## * BaseMatrixOps (pinned SHA) headers -> /usr/local/include/BaseMatrixOps +## +## All dependency content (URLs, versions, package lists) is embedded here. +################################################################################ + +# Fail loudly when sourced; do not swallow errors. +if [ "${BASH_SOURCE[0]}" != "$0" ]; then + : # sourced as intended +else + echo "download.sh must be sourced, not executed directly." >&2 + exit 1 +fi + +set -e + +BASE_INC="/usr/local/include" + +echo "[download] Installing system packages (Eigen, BLAS, LAPACK)..." +apt-get update -y +apt-get install -y libeigen3-dev libblas-dev liblapack-dev + +################################################################################ +## autodiff v1.1.2 (header-only reverse-mode AD) -> /usr/local/include/autodiff +################################################################################ +AD_VERSION="1.1.2" +AD_TAG="v${AD_VERSION}" +AD_URL="https://github.com/autodiff/autodiff/archive/refs/tags/${AD_TAG}.tar.gz" +AD_TMP="$(mktemp -d)" +echo "[download] Fetching autodiff ${AD_TAG} from ${AD_URL}" +curl -fSL -o "${AD_TMP}/autodiff.tgz" "${AD_URL}" +tar -xzf "${AD_TMP}/autodiff.tgz" -C "${AD_TMP}" +if [ ! -d "${AD_TMP}/autodiff-${AD_VERSION}/autodiff/reverse/var" ]; then + echo "[download] ERROR: autodiff archive layout unexpected." >&2 + rm -rf "${AD_TMP}" + return 1 +fi +rm -rf "${BASE_INC}/autodiff" +mkdir -p "${BASE_INC}/autodiff" +cp -r "${AD_TMP}/autodiff-${AD_VERSION}/autodiff/." "${BASE_INC}/autodiff/" +rm -rf "${AD_TMP}" +if [ ! -f "${BASE_INC}/autodiff/reverse/var/eigen.hpp" ]; then + echo "[download] ERROR: autodiff headers not installed to ${BASE_INC}." >&2 + return 1 +fi +echo "[download] autodiff installed to ${BASE_INC}/autodiff" + +export AUTODIFF_INCLUDE_PATH="${BASE_INC}" + +################################################################################ +## BaseMatrixOps (pinned commit) -> /usr/local/include/BaseMatrixOps +################################################################################ +BMO_SHA="9e5beec15d803f0429dadae5e9218ef907271383" +BMO_URL="https://github.com/kthohr/BaseMatrixOps/archive/${BMO_SHA}.tar.gz" +BMO_TMP="$(mktemp -d)" +echo "[download] Fetching BaseMatrixOps @ ${BMO_SHA}" +curl -fSL -o "${BMO_TMP}/bmo.tgz" "${BMO_URL}" +tar -xzf "${BMO_TMP}/bmo.tgz" -C "${BMO_TMP}" +if [ ! -f "${BMO_TMP}/BaseMatrixOps-${BMO_SHA}/include/BaseMatrixOps.hpp" ]; then + echo "[download] ERROR: BaseMatrixOps archive layout unexpected." >&2 + rm -rf "${BMO_TMP}" + return 1 +fi +rm -rf "${BASE_INC}/BaseMatrixOps" +mkdir -p "${BASE_INC}/BaseMatrixOps" +cp -r "${BMO_TMP}/BaseMatrixOps-${BMO_SHA}/." "${BASE_INC}/BaseMatrixOps/" +rm -rf "${BMO_TMP}" +if [ ! -f "${BASE_INC}/BaseMatrixOps/include/BaseMatrixOps.hpp" ]; then + echo "[download] ERROR: BaseMatrixOps headers not installed to ${BASE_INC}." >&2 + return 1 +fi +echo "[download] BaseMatrixOps installed to ${BASE_INC}/BaseMatrixOps" + +export BMO_INCLUDE_PATH="${BASE_INC}/BaseMatrixOps" + +################################################################################ +## Eigen include path (the OptimLib configure needs EIGEN_INCLUDE_PATH exported) +################################################################################ +if [ -d "/usr/include/eigen3/Eigen" ]; then + export EIGEN_INCLUDE_PATH="/usr/include/eigen3" + echo "[download] Eigen found at ${EIGEN_INCLUDE_PATH}" +else + echo "[download] ERROR: /usr/include/eigen3/Eigen not found after apt install." >&2 + return 1 +fi + +echo "[download] download.sh finished successfully." diff --git a/kthohr--optim.5453f48/environment/executable b/kthohr--optim.5453f48/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..96e81289cbf39d90eb64bcf39b0879343e3a1284 --- /dev/null +++ b/kthohr--optim.5453f48/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4a388718ea2cbb98a7d9dd319cfbffcd09d48ae2ed537914ce5eda9623af26a7 +size 2915080 diff --git a/kthohr--optim.5453f48/environment/harbor_configure_apt_mirror.sh b/kthohr--optim.5453f48/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kthohr--optim.5453f48/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kthohr--optim.5453f48/environment/harbor_prepare_download_env.sh b/kthohr--optim.5453f48/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kthohr--optim.5453f48/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kthohr--optim.5453f48/environment/workspace.tar.gz b/kthohr--optim.5453f48/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..360bbc4324f720edb8b3e340aa384eb795dd944d --- /dev/null +++ b/kthohr--optim.5453f48/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:579c40234cdead87759078b5003a9e72e1fce7d3a616d48ee0293cec6516b3a9 +size 10905 diff --git a/kthohr--optim.5453f48/instruction.md b/kthohr--optim.5453f48/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kthohr--optim.5453f48/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kthohr--optim.5453f48/solution/solve.sh b/kthohr--optim.5453f48/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kthohr--optim.5453f48/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kthohr--optim.5453f48/task.toml b/kthohr--optim.5453f48/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2e083c336fd41ed4b1c2eaa4c4fa8ce05b9b4937 --- /dev/null +++ b/kthohr--optim.5453f48/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kthohr--optim.5453f48" +description = "Synthetic ProgramGym cleanroom reconstruction task for kthohr/optim" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kthohr__optim.5453f48" +repository = "kthohr/optim" +commit = "5453f48aca695e6fef123677f35cb4d22e356e73" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.8606374167737547 +test_branches = 5 +test_count = 292 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kthohr--optim.5453f48/tests/Dockerfile b/kthohr--optim.5453f48/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ae6071510c9375ad35caf40d5f0fc02507509a77 --- /dev/null +++ b/kthohr--optim.5453f48/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kthohr--optim.5453f48/tests/blobs/tests/generated_module_01.tar.gz b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..23f2433389e2d9be013c67fb2e4b332e1668d1ce --- /dev/null +++ b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8e27d9dcb0f34dd3174d27333ea9d5925de4e56303de9ca5fd70f0e458afc3c +size 16097 diff --git a/kthohr--optim.5453f48/tests/blobs/tests/generated_module_02.tar.gz b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ebc907d757e464c09724a4695cc601d3f690a65d --- /dev/null +++ b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f16c09a755d6932933e2cc2b6826e6c43d3dcfbba822e884f20cc4441d7b3ee5 +size 7774 diff --git a/kthohr--optim.5453f48/tests/blobs/tests/generated_module_03.tar.gz b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8b46e657575dfe840a8008ef481df44b75cbaa28 --- /dev/null +++ b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8427f64cc76eb39ad65efc7a6c3f8c862d66240d7c7d8a45bbb483ac5919b988 +size 12787 diff --git a/kthohr--optim.5453f48/tests/blobs/tests/generated_module_04.tar.gz b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6dc823241f6eb9c4e8cfe6db45ce9defe29fb85e --- /dev/null +++ b/kthohr--optim.5453f48/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d34b47894de1c75299dd82e6818a881242a29491096105cc3d7059d1bb50d542 +size 16695 diff --git a/kthohr--optim.5453f48/tests/blobs/tests/generated_upstream.tar.gz b/kthohr--optim.5453f48/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..74aa65321a9fe450edc45efdf95b03f39e3da201 --- /dev/null +++ b/kthohr--optim.5453f48/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86a7ddaa3f30d02e6be6d73cc3d528c70c41c9133dcb3a5bdbde9fb03307ee44 +size 3011 diff --git a/kthohr--optim.5453f48/tests/docker-compose.yaml b/kthohr--optim.5453f48/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kthohr--optim.5453f48/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kthohr--optim.5453f48/tests/download.sh b/kthohr--optim.5453f48/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..3e38ccab397a0fc95548ecb742b665912a6d4d77 --- /dev/null +++ b/kthohr--optim.5453f48/tests/download.sh @@ -0,0 +1,98 @@ +#!/usr/bin/env bash +################################################################################ +## ProgramGym download.sh -- OptimLib (kthohr/optim) +## +## Networked, standalone stage. Sourced via `source /source_ro/download.sh`. +## It must NOT read any repository file, must NOT compile/test/build, and must +## be safe to re-source (idempotent). +## +## It prepares, for the later offline build.sh: +## * apt system packages: libeigen3-dev (Eigen headers), libblas-dev and +## liblapack-dev (link symbols required by the project's `make` target). +## * autodiff v1.1.2 headers -> /usr/local/include/autodiff +## * BaseMatrixOps (pinned SHA) headers -> /usr/local/include/BaseMatrixOps +## +## All dependency content (URLs, versions, package lists) is embedded here. +################################################################################ + +# Fail loudly when sourced; do not swallow errors. +if [ "${BASH_SOURCE[0]}" != "$0" ]; then + : # sourced as intended +else + echo "download.sh must be sourced, not executed directly." >&2 + exit 1 +fi + +set -e + +BASE_INC="/usr/local/include" + +echo "[download] Installing system packages (Eigen, BLAS, LAPACK)..." +apt-get update -y +apt-get install -y libeigen3-dev libblas-dev liblapack-dev + +################################################################################ +## autodiff v1.1.2 (header-only reverse-mode AD) -> /usr/local/include/autodiff +################################################################################ +AD_VERSION="1.1.2" +AD_TAG="v${AD_VERSION}" +AD_URL="https://github.com/autodiff/autodiff/archive/refs/tags/${AD_TAG}.tar.gz" +AD_TMP="$(mktemp -d)" +echo "[download] Fetching autodiff ${AD_TAG} from ${AD_URL}" +curl -fSL -o "${AD_TMP}/autodiff.tgz" "${AD_URL}" +tar -xzf "${AD_TMP}/autodiff.tgz" -C "${AD_TMP}" +if [ ! -d "${AD_TMP}/autodiff-${AD_VERSION}/autodiff/reverse/var" ]; then + echo "[download] ERROR: autodiff archive layout unexpected." >&2 + rm -rf "${AD_TMP}" + return 1 +fi +rm -rf "${BASE_INC}/autodiff" +mkdir -p "${BASE_INC}/autodiff" +cp -r "${AD_TMP}/autodiff-${AD_VERSION}/autodiff/." "${BASE_INC}/autodiff/" +rm -rf "${AD_TMP}" +if [ ! -f "${BASE_INC}/autodiff/reverse/var/eigen.hpp" ]; then + echo "[download] ERROR: autodiff headers not installed to ${BASE_INC}." >&2 + return 1 +fi +echo "[download] autodiff installed to ${BASE_INC}/autodiff" + +export AUTODIFF_INCLUDE_PATH="${BASE_INC}" + +################################################################################ +## BaseMatrixOps (pinned commit) -> /usr/local/include/BaseMatrixOps +################################################################################ +BMO_SHA="9e5beec15d803f0429dadae5e9218ef907271383" +BMO_URL="https://github.com/kthohr/BaseMatrixOps/archive/${BMO_SHA}.tar.gz" +BMO_TMP="$(mktemp -d)" +echo "[download] Fetching BaseMatrixOps @ ${BMO_SHA}" +curl -fSL -o "${BMO_TMP}/bmo.tgz" "${BMO_URL}" +tar -xzf "${BMO_TMP}/bmo.tgz" -C "${BMO_TMP}" +if [ ! -f "${BMO_TMP}/BaseMatrixOps-${BMO_SHA}/include/BaseMatrixOps.hpp" ]; then + echo "[download] ERROR: BaseMatrixOps archive layout unexpected." >&2 + rm -rf "${BMO_TMP}" + return 1 +fi +rm -rf "${BASE_INC}/BaseMatrixOps" +mkdir -p "${BASE_INC}/BaseMatrixOps" +cp -r "${BMO_TMP}/BaseMatrixOps-${BMO_SHA}/." "${BASE_INC}/BaseMatrixOps/" +rm -rf "${BMO_TMP}" +if [ ! -f "${BASE_INC}/BaseMatrixOps/include/BaseMatrixOps.hpp" ]; then + echo "[download] ERROR: BaseMatrixOps headers not installed to ${BASE_INC}." >&2 + return 1 +fi +echo "[download] BaseMatrixOps installed to ${BASE_INC}/BaseMatrixOps" + +export BMO_INCLUDE_PATH="${BASE_INC}/BaseMatrixOps" + +################################################################################ +## Eigen include path (the OptimLib configure needs EIGEN_INCLUDE_PATH exported) +################################################################################ +if [ -d "/usr/include/eigen3/Eigen" ]; then + export EIGEN_INCLUDE_PATH="/usr/include/eigen3" + echo "[download] Eigen found at ${EIGEN_INCLUDE_PATH}" +else + echo "[download] ERROR: /usr/include/eigen3/Eigen not found after apt install." >&2 + return 1 +fi + +echo "[download] download.sh finished successfully." diff --git a/kthohr--optim.5453f48/tests/executable b/kthohr--optim.5453f48/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..96e81289cbf39d90eb64bcf39b0879343e3a1284 --- /dev/null +++ b/kthohr--optim.5453f48/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4a388718ea2cbb98a7d9dd319cfbffcd09d48ae2ed537914ce5eda9623af26a7 +size 2915080 diff --git a/kthohr--optim.5453f48/tests/harbor_configure_apt_mirror.sh b/kthohr--optim.5453f48/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kthohr--optim.5453f48/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kthohr--optim.5453f48/tests/harbor_prepare_download_env.sh b/kthohr--optim.5453f48/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kthohr--optim.5453f48/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kthohr--optim.5453f48/tests/programgym_evaluator.py b/kthohr--optim.5453f48/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kthohr--optim.5453f48/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kthohr--optim.5453f48/tests/programgym_task.json b/kthohr--optim.5453f48/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..5e98789c91304022e79e93014875150ec22d95fd --- /dev/null +++ b/kthohr--optim.5453f48/tests/programgym_task.json @@ -0,0 +1,490 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_output_stream_contract.test_stderr_merged_into_stdout_file_stays_clean", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_output_stream_contract.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_autodiscovery_json_options_in_cwd_is_ignored", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_cwd_config_plus_foreign_env_config_are_both_ignored", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_display_name_of_executable_does_not_change_output", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_mixed_cwd_with_multiple_real_files_is_ignored", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_multi_file_argv_batch_is_ignored", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_real_config_streamed_on_stdin_is_ignored[cfg_doc]", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_real_config_streamed_on_stdin_is_ignored[data_doc]", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_real_config_streamed_on_stdin_is_ignored[json_doc]", + "eval.tests.test_autodiscovery_and_argv0_ignorance.test_single_config_file_in_cwd_is_ignored", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[etc]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[home]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[lang_c]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[lc_all_c]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[python_hashseed]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[tz_new_york]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[tz_utc]", + "eval.tests.test_config_independence.test_environment_locale_and_host_vars_do_not_alter_output[user]", + "eval.tests.test_config_independence.test_optimizer_config_file_argument_is_not_consumed", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[algorithm_nelder_mead]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[algorithm_swarm]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[conv_failure]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[debug]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[grad_tol]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[iter_max]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[vals_bound]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[verbose]", + "eval.tests.test_config_independence.test_optimizer_environment_variables_do_not_alter_output[wolfe_c1]", + "eval.tests.test_config_independence.test_output_is_identical_from_any_working_directory", + "eval.tests.test_config_independence.test_runs_from_clean_working_directory_leave_no_files", + "eval.tests.test_config_independence.test_sequential_runs_are_reproducible", + "eval.tests.test_input_ignorance.test_env_config_path_to_real_file_is_ignored[config]", + "eval.tests.test_input_ignorance.test_env_config_path_to_real_file_is_ignored[control]", + "eval.tests.test_input_ignorance.test_env_config_path_to_real_file_is_ignored[options]", + "eval.tests.test_input_ignorance.test_env_config_path_to_real_file_is_ignored[settings]", + "eval.tests.test_input_ignorance.test_foreign_working_directory_preserves_full_channel_contract", + "eval.tests.test_input_ignorance.test_many_foreign_cwd_runs_match_golden_and_leave_no_files", + "eval.tests.test_input_ignorance.test_real_config_file_argument_is_ignored", + "eval.tests.test_input_ignorance.test_real_data_file_does_not_seed_initial_vector", + "eval.tests.test_input_ignorance.test_real_json_options_argument_is_ignored", + "eval.tests.test_output_format_invariants.test_printed_numbers_reproduce_golden_numeric_payload", + "eval.tests.test_output_format_invariants.test_program_finishes_within_bounded_wall_clock", + "eval.tests.test_output_format_invariants.test_report_has_canonical_structured_topology", + "eval.tests.test_output_format_invariants.test_solution_preserves_negative_and_positive_components", + "eval.tests.test_output_format_invariants.test_stdout_uses_lf_line_terminators_only", + "eval.tests.test_output_stream_contract.test_byte_length_of_report_is_stable_across_runs", + "eval.tests.test_output_stream_contract.test_output_sink_dev_null_still_runs_solve_and_clean_stderr", + "eval.tests.test_output_stream_contract.test_redirected_file_has_exact_golden_length", + "eval.tests.test_output_stream_contract.test_report_length_is_one_constant_for_all_sinks", + "eval.tests.test_output_stream_contract.test_solved_report_terminates_in_single_newline", + "eval.tests.test_output_stream_contract.test_stderr_merged_into_stdout_file_stays_clean", + "eval.tests.test_output_stream_contract.test_stdout_and_stderr_redirect_to_distinct_files", + "eval.tests.test_output_stream_contract.test_stdout_redirect_to_file_reproduces_golden", + "eval.tests.test_parallel_invocation.test_concurrent_invocations_are_identical", + "eval.tests.test_parallel_invocation.test_concurrent_invocations_exit_uniformly_successful", + "eval.tests.test_parallel_invocation.test_concurrent_run_outputs_are_stable_bytes", + "eval.tests.test_process_contract.test_arbitrary_stdin_is_ignored[binary]", + "eval.tests.test_process_contract.test_arbitrary_stdin_is_ignored[blank_lines]", + "eval.tests.test_process_contract.test_arbitrary_stdin_is_ignored[empty]", + "eval.tests.test_process_contract.test_arbitrary_stdin_is_ignored[five_lines]", + "eval.tests.test_process_contract.test_arbitrary_stdin_is_ignored[word]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[algorithm_arg]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[double_dash_options]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[help_long]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[help_short]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[no_args]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[numeric_arg]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[single_positional]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[three_positionals]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[verbose]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[version_long]", + "eval.tests.test_process_contract.test_command_line_arguments_are_not_consumed[version_short]", + "eval.tests.test_process_contract.test_empty_stdin_does_not_change_stdout", + "eval.tests.test_process_contract.test_exit_code_is_zero_on_success", + "eval.tests.test_process_contract.test_solution_header_line_present", + "eval.tests.test_process_contract.test_stderr_is_empty_on_success", + "eval.tests.test_process_contract.test_stdout_exactly_matches_golden_baseline", + "eval.tests.test_process_contract.test_stdout_is_lossless_against_golden", + "eval.tests.test_process_contract.test_stdout_is_not_empty_but_stderr_is", + "eval.tests.test_process_contract.test_stdout_line_structure_matches_golden", + "eval.tests.test_process_contract.test_success_line_appears_exactly_once", + "eval.tests.test_process_contract.test_success_line_present_and_exact", + "eval.tests.test_process_contract.test_trailing_arguments_preserve_solution", + "eval.tests.test_residual_solution.test_each_component_converges_to_sphere_minimum", + "eval.tests.test_residual_solution.test_implied_sphere_objective_is_near_zero", + "eval.tests.test_residual_solution.test_max_component_magnitude_well_below_start_radius", + "eval.tests.test_residual_solution.test_no_component_drifts_toward_starting_magnitude", + "eval.tests.test_residual_solution.test_rows_are_finite_and_parseable", + "eval.tests.test_residual_solution.test_rows_are_mutually_near_each_other", + "eval.tests.test_residual_solution.test_solution_has_exactly_five_components", + "eval.tests.test_residual_solution.test_solution_is_distinct_from_initial_vector", + "eval.tests.test_residual_solution.test_solution_print_respects_ordering_of_header" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args0]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args10]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args11]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args12]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args13]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args1]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args2]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args3]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args4]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args5]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args6]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args7]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args8]", + "eval.tests.test_invocation.test_every_invocation_prints_identical_golden[args9]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args0]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args10]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args11]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args12]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args13]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args1]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args2]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args3]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args4]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args5]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args6]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args7]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args8]", + "eval.tests.test_invocation.test_every_invocation_stdout_length_stable[args9]", + "eval.tests.test_invocation.test_invocation_through_renamed_symlink_is_identical", + "eval.tests.test_invocation.test_long_argv_beyond_typical_limit_is_ignored", + "eval.tests.test_invocation.test_output_ignores_cwd_and_environment_position", + "eval.tests.test_invocation.test_output_not_influenced_by_empty_stdin", + "eval.tests.test_invocation.test_piped_invalid_utf8_byte_stream_is_ignored", + "eval.tests.test_invocation.test_piped_stdin_does_not_alter_output", + "eval.tests.test_invocation.test_repeated_runs_are_byte_identical", + "eval.tests.test_invocation.test_unknown_flag_with_numeric_argument_is_ignored", + "eval.tests.test_output_contract.test_default_stdout_line_endings_are_lf_only", + "eval.tests.test_output_contract.test_default_stdout_matches_golden_exactly", + "eval.tests.test_output_contract.test_exit_status_is_zero_with_full_output", + "eval.tests.test_output_contract.test_first_line_reports_successful_bfgs_run", + "eval.tests.test_output_contract.test_merged_streams_contain_only_the_reference_block", + "eval.tests.test_output_contract.test_output_ends_with_final_newline", + "eval.tests.test_output_contract.test_output_reuses_consistent_header_and_solution_separators", + "eval.tests.test_output_contract.test_solution_header_present", + "eval.tests.test_output_contract.test_stderr_is_empty", + "eval.tests.test_output_contract.test_stdout_is_exactly_expected_line_count", + "eval.tests.test_output_contract.test_stdout_redirected_to_file_is_byte_identical", + "eval.tests.test_solution_semantics.test_all_solution_components_are_finite", + "eval.tests.test_solution_semantics.test_component_order_matches_golden_gradient", + "eval.tests.test_solution_semantics.test_component_sum_is_nonzero", + "eval.tests.test_solution_semantics.test_final_component_is_the_negative_residual", + "eval.tests.test_solution_semantics.test_first_component_is_small_positive_offset", + "eval.tests.test_solution_semantics.test_numeric_rows_use_eigen_scientific_formatting", + "eval.tests.test_solution_semantics.test_positive_components_outnumber_negative", + "eval.tests.test_solution_semantics.test_solution_component_magnitudes_form_a_peak", + "eval.tests.test_solution_semantics.test_solution_has_exactly_five_components", + "eval.tests.test_solution_semantics.test_solution_lands_at_sphere_minimum_near_origin", + "eval.tests.test_solution_semantics.test_solution_matches_exact_golden_values" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_contract.test_exit_code_zero_with_success", + "eval.tests.test_cli_contract.test_first_line_is_success_message", + "eval.tests.test_cli_contract.test_output_deterministic_across_five_runs", + "eval.tests.test_cli_contract.test_solution_components_are_finite", + "eval.tests.test_cli_contract.test_solution_has_exactly_five_components", + "eval.tests.test_cli_contract.test_solution_header_present", + "eval.tests.test_cli_contract.test_solution_is_printed_after_blank_line", + "eval.tests.test_cli_contract.test_stderr_is_empty_on_success", + "eval.tests.test_cli_contract.test_stdout_matches_golden_exactly", + "eval.tests.test_cli_contract.test_success_marker_is_exact_string", + "eval.tests.test_cli_contract.test_unsuccessful_marker_is_absent", + "eval.tests.test_output_schema.test_component_sign_alignment_layout", + "eval.tests.test_output_schema.test_every_component_uses_scientific_notation", + "eval.tests.test_output_schema.test_report_byte_length_is_exact", + "eval.tests.test_output_schema.test_report_ends_with_single_newline", + "eval.tests.test_output_schema.test_report_line_roles_and_count", + "eval.tests.test_output_schema.test_solution_values_round_trip_through_print_format", + "eval.tests.test_process_contract.test_executable_is_a_real_elf_binary", + "eval.tests.test_process_contract.test_no_crash_on_absolute_path_invocation", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args0-no_arguments]", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args1-single_float_argument]", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args2-many_arguments]", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args3-help_flag]", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args4-version_flag]", + "eval.tests.test_process_contract.test_program_output_is_input_insensitive[args5-short_help_flag]", + "eval.tests.test_process_contract.test_silent_nonzero_input_does_not_alter_exit", + "eval.tests.test_process_contract.test_stdin_is_ignored", + "eval.tests.test_process_contract.test_terminates_promptly", + "eval.tests.test_process_isolation.test_no_files_created_in_working_directory", + "eval.tests.test_process_isolation.test_no_output_file_created_next_to_executable", + "eval.tests.test_process_isolation.test_report_is_invariant_to_environment[MY_OPTIM_TEST_FLAG-yes]", + "eval.tests.test_process_isolation.test_report_is_invariant_to_environment[OPTIM_LINE_SEARCH-backtracking]", + "eval.tests.test_process_isolation.test_report_is_invariant_to_environment[OPTIM_NUM_THREADS-8]", + "eval.tests.test_process_isolation.test_report_is_invariant_to_environment[OPTIM_SILENT-true]", + "eval.tests.test_process_isolation.test_report_is_invariant_to_environment[OPTIM_TRACE-1]", + "eval.tests.test_process_isolation.test_threading_env_variables_do_not_change_result[OMP_NUM_THREADS-4]", + "eval.tests.test_process_isolation.test_threading_env_variables_do_not_change_result[OPENBLAS_NUM_THREADS-2]", + "eval.tests.test_report_bytes.test_each_component_line_is_exact_fixed_width", + "eval.tests.test_report_bytes.test_large_binary_stdin_does_not_change_report[ascii_digits]", + "eval.tests.test_report_bytes.test_large_binary_stdin_does_not_change_report[full_byte_range]", + "eval.tests.test_report_bytes.test_large_binary_stdin_does_not_change_report[highbytes]", + "eval.tests.test_report_bytes.test_report_has_no_carriage_returns", + "eval.tests.test_report_bytes.test_report_has_no_utf8_bom", + "eval.tests.test_report_bytes.test_report_is_ascii_only", + "eval.tests.test_report_bytes.test_twenty_serialized_runs_all_report_identically", + "eval.tests.test_sphere_optimization.test_all_solution_components_converge_to_origin", + "eval.tests.test_sphere_optimization.test_components_are_small_signed_floats", + "eval.tests.test_sphere_optimization.test_every_component_individually_near_zero", + "eval.tests.test_sphere_optimization.test_first_starting_component_reflected_in_final_state", + "eval.tests.test_sphere_optimization.test_objective_value_after_optimization_is_tiny", + "eval.tests.test_sphere_optimization.test_solution_approximates_null_vector" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_invocation_invariance.test_output_invariant_to_renamed_argv0", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_invocation_invariance.test_output_invariant_to_working_directory", + "reasons": [ + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_invocation_invariance.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_determinism.test_solution_leading_components_stable", + "eval.tests.test_determinism.test_solution_row_count_stable_across_runs", + "eval.tests.test_determinism.test_solution_values_identical_across_runs", + "eval.tests.test_determinism.test_stdout_identical_across_runs", + "eval.tests.test_determinism.test_success_message_stable_across_runs", + "eval.tests.test_invocation_invariance.test_output_invariant_to_environment_variable[OPTIM_SEED-123]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_environment_variable[OPTIM_TEST-x]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_environment_variable[PB_PROBE-1]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[--help]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[--unknown]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[--version]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[-]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[-v]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[-x]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_extra_argv_token[42]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_piped_stdin[7.25\\n]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_piped_stdin[]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_piped_stdin[line one\\nline two\\n]", + "eval.tests.test_invocation_invariance.test_output_invariant_to_renamed_argv0", + "eval.tests.test_invocation_invariance.test_output_invariant_to_working_directory", + "eval.tests.test_numerical_convergence.test_each_solution_component_is_near_zero", + "eval.tests.test_numerical_convergence.test_implied_objective_near_zero", + "eval.tests.test_numerical_convergence.test_max_abs_component_below_gradient_tolerance", + "eval.tests.test_numerical_convergence.test_solution_component_index_within_tolerance[0]", + "eval.tests.test_numerical_convergence.test_solution_component_index_within_tolerance[1]", + "eval.tests.test_numerical_convergence.test_solution_component_index_within_tolerance[2]", + "eval.tests.test_numerical_convergence.test_solution_component_index_within_tolerance[3]", + "eval.tests.test_numerical_convergence.test_solution_component_index_within_tolerance[4]", + "eval.tests.test_numerical_convergence.test_solution_is_at_global_minimum_of_sphere", + "eval.tests.test_numerical_convergence.test_solution_value_is_finite_and_tiny[0]", + "eval.tests.test_numerical_convergence.test_solution_value_is_finite_and_tiny[1]", + "eval.tests.test_numerical_convergence.test_solution_value_is_finite_and_tiny[2]", + "eval.tests.test_numerical_convergence.test_solution_value_is_finite_and_tiny[3]", + "eval.tests.test_numerical_convergence.test_solution_value_is_finite_and_tiny[4]", + "eval.tests.test_output_invariants.test_optimizer_moved_from_initial_point", + "eval.tests.test_output_invariants.test_output_ends_with_single_newline_no_trailing_blank", + "eval.tests.test_output_invariants.test_output_has_exact_line_count", + "eval.tests.test_output_invariants.test_row_whitespace_and_single_negative_sign", + "eval.tests.test_output_invariants.test_solution_stable_across_three_runs", + "eval.tests.test_output_invariants.test_stdout_is_pure_ascii_printable", + "eval.tests.test_output_invariants.test_total_stdout_byte_length_is_stable", + "eval.tests.test_parse_robustness.test_all_rows_match_number_grammar", + "eval.tests.test_parse_robustness.test_parsed_values_stable_over_reparse", + "eval.tests.test_parse_robustness.test_solution_components_are_subnanoscale", + "eval.tests.test_parse_robustness.test_solution_contains_a_negative_component", + "eval.tests.test_parse_robustness.test_solution_header_rendering", + "eval.tests.test_parse_robustness.test_solution_rows_are_nonempty", + "eval.tests.test_rendering_format.test_each_row_has_six_significant_digit_mantissa", + "eval.tests.test_rendering_format.test_each_row_is_fixed_width_scientific_grammar", + "eval.tests.test_rendering_format.test_exponent_is_signed_two_digit", + "eval.tests.test_rendering_format.test_implied_objective_is_machine_precision_zero", + "eval.tests.test_rendering_format.test_mantissa_and_exponent_reconstruct_parsed_value", + "eval.tests.test_rendering_format.test_mantissa_column_is_aligned_across_rows", + "eval.tests.test_rendering_format.test_printed_exponent_matches_parsed_magnitude", + "eval.tests.test_rendering_format.test_row_count_matches_decision_variable_dimension", + "eval.tests.test_rendering_format.test_sign_column_is_exactly_one_character", + "eval.tests.test_solution_geography.test_every_component_is_nonzero_and_finite[0]", + "eval.tests.test_solution_geography.test_every_component_is_nonzero_and_finite[1]", + "eval.tests.test_solution_geography.test_every_component_is_nonzero_and_finite[2]", + "eval.tests.test_solution_geography.test_every_component_is_nonzero_and_finite[3]", + "eval.tests.test_solution_geography.test_every_component_is_nonzero_and_finite[4]", + "eval.tests.test_solution_geography.test_exponent_sequence_is_exact_ordered_pattern", + "eval.tests.test_solution_geography.test_extremal_magnitudes_sit_at_exact_indices", + "eval.tests.test_solution_geography.test_leading_component_is_strictly_smallest", + "eval.tests.test_solution_geography.test_magnitude_span_is_exactly_two_orders", + "eval.tests.test_solution_geography.test_middle_component_is_the_strict_dominant_term", + "eval.tests.test_solution_geography.test_negative_component_is_only_the_last_row", + "eval.tests.test_solution_geography.test_signed_sum_is_small_positive", + "eval.tests.test_solution_geography.test_signed_total_matches_positive_negative_split", + "eval.tests.test_solution_structure.test_all_solution_values_finite", + "eval.tests.test_solution_structure.test_each_solution_row_parses_as_scientific_number", + "eval.tests.test_solution_structure.test_parse_solution_exact_count[5]", + "eval.tests.test_solution_structure.test_solution_block_is_contiguous_numbers_only", + "eval.tests.test_solution_structure.test_solution_has_five_values", + "eval.tests.test_solution_structure.test_solution_header_is_present", + "eval.tests.test_solution_structure.test_solution_header_position_and_preceding_lines", + "eval.tests.test_streams.test_banner_only_on_stdout_not_stderr", + "eval.tests.test_streams.test_golden_stdout_matches_exact_output", + "eval.tests.test_streams.test_solution_header_only_on_stdout_not_stderr", + "eval.tests.test_streams.test_stderr_is_empty_from_executable", + "eval.tests.test_streams.test_stdout_is_non_empty_and_bears_banner", + "eval.tests.test_success_output.test_converged_run_does_not_crash", + "eval.tests.test_success_output.test_converged_run_exit_code_is_zero", + "eval.tests.test_success_output.test_no_failure_message_when_converged[bfgs error:]", + "eval.tests.test_success_output.test_no_failure_message_when_converged[non-finite initial value]", + "eval.tests.test_success_output.test_no_failure_message_when_converged[optim failure:]", + "eval.tests.test_success_output.test_no_iteration_error_detail_lines_when_converged", + "eval.tests.test_success_output.test_success_banner_exact_text_and_line", + "eval.tests.test_success_output.test_success_banner_occurs_exactly_once", + "eval.tests.test_success_output.test_success_banner_printed_when_converged", + "eval.tests.test_success_output.test_success_message_is_first_output_line" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_bfgs_upstream.test_bfgs_iterate_moves_from_start_toward_minimum", + "eval.tests.test_bfgs_upstream.test_bfgs_objective_reaches_global_minimum", + "eval.tests.test_bfgs_upstream.test_bfgs_reports_convergence_success", + "eval.tests.test_bfgs_upstream.test_bfgs_solution_converges_to_analytic_minimum" + ] + } + }, + "commit": "5453f48aca695e6fef123677f35cb4d22e356e73", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.8606374167737547, + "eval_clean_hashes": [ + "4a388718ea2cbb98a7d9dd319cfbffcd09d48ae2ed537914ce5eda9623af26a7" + ], + "input_record": { + "commit": "5453f48aca695e6fef123677f35cb4d22e356e73", + "difficulty": "easy", + "difficulty_code_lines": 7255, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 7255, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.8606374167737547, + "difficulty_test_code_lines": 4234, + "full_name": "kthohr/optim", + "input_joern_zip": "cpp_joern/kthohr__optim.zip", + "joern_status": true, + "joern_time": 19.154414826072752, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 548, + "similarity": 0.477344274520874 + }, + { + "pb_fullname": "facebookresearch/fastText", + "rank": 923, + "similarity": 0.41897520422935486 + } + ], + "repo_path": "cpp/kthohr__optim", + "source": "commit:5453f48aca695e6fef123677f35cb4d22e356e73", + "status": "done", + "url": "https://github.com/kthohr/optim" + }, + "instance_id": "kthohr__optim.5453f48", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 4, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_upstream", + "iteration_limit": 5, + "module_index": 5, + "module_kind": "tests", + "termination_reason": "early_stopping" + } + ], + "repository": "kthohr/optim" +} diff --git a/kthohr--optim.5453f48/tests/test.sh b/kthohr--optim.5453f48/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kthohr--optim.5453f48/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kthohr--optim.5453f48/tests/workspace.tar.gz b/kthohr--optim.5453f48/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..360bbc4324f720edb8b3e340aa384eb795dd944d --- /dev/null +++ b/kthohr--optim.5453f48/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:579c40234cdead87759078b5003a9e72e1fce7d3a616d48ee0293cec6516b3a9 +size 10905 diff --git a/kubecfg--kubecfg.64da3e7/environment/Dockerfile b/kubecfg--kubecfg.64da3e7/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..5cf965202bf3f2bdbe7faab773b15c8629800597 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/Dockerfile @@ -0,0 +1,64 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kubecfg--kubecfg.64da3e7/environment/download.sh b/kubecfg--kubecfg.64da3e7/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..a95b67a64f59a2f14ee125f1a3d85effca8e6501 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/download.sh @@ -0,0 +1,2179 @@ +#!/usr/bin/env bash +# ProgramGym Go download.sh for github.com/kubecfg/kubecfg (module mode). +# Standalone dependency-prefetch stage. Generates go.mod/go.sum inline, then +# runs `go mod download` so the offline `build.sh` can build ./executable with +# no network access. The module version pins match the repository's go.mod. + +set -euo pipefail + +# The pipeline runs the base-image Go toolchain. go.mod declares go 1.24.5 and +# the base toolchain is 1.25.x, so it is sufficient; use the base GOROOT. +GO=$(command -v go) + +PREFETCH_DIR="/workspace/.programgym_build_env/go-prefetch" +mkdir -p "$PREFETCH_DIR" + +# Embedded go.mod, byte-for-byte identical to the repository's go.mod. +cat > "$PREFETCH_DIR/go.mod" <<'GOMOD_EOF' +module github.com/kubecfg/kubecfg + +require ( + github.com/Masterminds/sprig/v3 v3.3.0 + github.com/containerd/containerd v1.7.30 + github.com/docker/cli v28.5.1+incompatible + github.com/evanphx/json-patch/v5 v5.9.11 + github.com/ghodss/yaml v1.0.0 + github.com/go-git/go-git/v5 v5.17.1 + github.com/golang/protobuf v1.5.4 + github.com/google/gnostic v0.7.0 + github.com/google/go-containerregistry v0.14.0 + github.com/google/go-jsonnet v0.22.0 + github.com/hexops/gotextdiff v1.0.3 + github.com/klauspost/compress v1.18.0 + github.com/kubecfg/ursonnet v0.1.1 + github.com/kubecfg/yaml/v2 v2.4.2 + github.com/mattn/go-isatty v0.0.20 + github.com/onsi/ginkgo/v2 v2.21.0 + github.com/onsi/gomega v1.35.1 + github.com/opencontainers/image-spec v1.1.1 + github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 + github.com/sirupsen/logrus v1.9.4 + github.com/spf13/cobra v1.10.1 + github.com/spf13/pflag v1.0.9 + github.com/spf13/viper v1.18.2 + github.com/stretchr/testify v1.11.1 + golang.org/x/crypto v0.45.0 + gopkg.in/yaml.v3 v3.0.1 + helm.sh/helm/v3 v3.18.5 + k8s.io/api v0.33.3 + k8s.io/apiextensions-apiserver v0.33.3 + k8s.io/apimachinery v0.33.3 + k8s.io/client-go v0.33.3 + k8s.io/klog/v2 v2.130.1 + k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff + k8s.io/kubectl v0.33.3 + oras.land/oras-go v1.2.7 + oras.land/oras-go/v2 v2.6.0 + sigs.k8s.io/kustomize/api v0.19.0 + sigs.k8s.io/kustomize/kyaml v0.19.0 +) + +require ( + dario.cat/mergo v1.0.1 // indirect + github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect + github.com/BurntSushi/toml v1.5.0 // indirect + github.com/Masterminds/goutils v1.1.1 // indirect + github.com/Masterminds/semver/v3 v3.3.0 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/ProtonMail/go-crypto v1.1.6 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cloudflare/circl v1.6.3 // indirect + github.com/containerd/errdefs v0.3.0 // indirect + github.com/containerd/log v0.1.0 // indirect + github.com/containerd/platforms v0.2.1 // indirect + github.com/cyphar/filepath-securejoin v0.5.1 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/distribution/reference v0.6.0 // indirect + github.com/docker/distribution v2.8.3+incompatible // indirect + github.com/docker/docker v28.5.1+incompatible // indirect + github.com/docker/docker-credential-helpers v0.8.2 // indirect + github.com/docker/go-connections v0.6.0 // indirect + github.com/docker/go-metrics v0.0.1 // indirect + github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect + github.com/emicklei/go-restful/v3 v3.11.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/fxamacker/cbor/v2 v2.7.0 // indirect + github.com/go-errors/errors v1.4.2 // indirect + github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect + github.com/go-git/go-billy/v5 v5.8.0 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-openapi/jsonpointer v0.21.0 // indirect + github.com/go-openapi/jsonreference v0.20.2 // indirect + github.com/go-openapi/swag v0.23.0 // indirect + github.com/go-task/slim-sprig/v3 v3.0.0 // indirect + github.com/gobwas/glob v0.2.3 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect + github.com/google/gnostic-models v0.6.9 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db // indirect + github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/mux v1.8.1 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/huandu/xstrings v1.5.0 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/kevinburke/ssh_config v1.2.0 // indirect + github.com/magiconair/properties v1.8.7 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/go-homedir v1.1.0 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/moby/locker v1.0.1 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/pelletier/go-toml/v2 v2.1.0 // indirect + github.com/pjbgf/sha1cd v0.3.2 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_golang v1.22.0 // indirect + github.com/prometheus/client_model v0.6.1 // indirect + github.com/prometheus/common v0.62.0 // indirect + github.com/prometheus/procfs v0.15.1 // indirect + github.com/sagikazarmark/locafero v0.4.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect + github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirect + github.com/shopspring/decimal v1.4.0 // indirect + github.com/skeema/knownhosts v1.3.1 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.7.0 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + github.com/x448/float16 v0.8.4 // indirect + github.com/xanzy/ssh-agent v0.3.3 // indirect + github.com/xlab/treeprint v1.2.0 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 // indirect + go.opentelemetry.io/otel v1.33.0 // indirect + go.opentelemetry.io/otel/metric v1.33.0 // indirect + go.opentelemetry.io/otel/trace v1.33.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect + go.yaml.in/yaml/v3 v3.0.3 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect + golang.org/x/net v0.47.0 // indirect + golang.org/x/oauth2 v0.30.0 // indirect + golang.org/x/sync v0.18.0 // indirect + golang.org/x/sys v0.38.0 // indirect + golang.org/x/term v0.37.0 // indirect + golang.org/x/text v0.31.0 // indirect + golang.org/x/time v0.12.0 // indirect + golang.org/x/tools v0.38.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 // indirect + google.golang.org/grpc v1.68.1 // indirect + google.golang.org/protobuf v1.36.5 // indirect + gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect + sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect + sigs.k8s.io/randfill v1.0.0 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect + sigs.k8s.io/yaml v1.5.0 // indirect +) + +go 1.24.5 + +GOMOD_EOF + +# Embedded go.sum, byte-for-byte identical to the repository's go.sum. +cat > "$PREFETCH_DIR/go.sum" <<'GOSUM_EOF' +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accessapproval v1.6.0/go.mod h1:R0EiYnwV5fsRFiKZkPHr6mwyk2wxUJ30nL4j2pcFY2E= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/accesscontextmanager v1.6.0/go.mod h1:8XCvZWfYw3K/ji0iVnp+6pu7huxoQTLmxAbVjbloTtM= +cloud.google.com/go/accesscontextmanager v1.7.0/go.mod h1:CEGLewx8dwa33aDAZQujl7Dx+uYhS0eay198wB/VumQ= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/aiplatform v1.35.0/go.mod h1:7MFT/vCaOyZT/4IIFfxH4ErVg/4ku6lKv3w0+tFTgXQ= +cloud.google.com/go/aiplatform v1.36.1/go.mod h1:WTm12vJRPARNvJ+v6P52RDHCNe4AhvjcIZ/9/RRHy/k= +cloud.google.com/go/aiplatform v1.37.0/go.mod h1:IU2Cv29Lv9oCn/9LkFiiuKfwrRTq+QQMbW+hPCxJGZw= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/analytics v0.17.0/go.mod h1:WXFa3WSym4IZ+JiKmavYdJwGG/CvpqiqczmL59bTD9M= +cloud.google.com/go/analytics v0.18.0/go.mod h1:ZkeHGQlcIPkw0R/GW+boWHhCOR43xz9RN/jn7WcqfIE= +cloud.google.com/go/analytics v0.19.0/go.mod h1:k8liqf5/HCnOUkbawNtrWWc+UAzyDlW89doe8TtoDsE= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigateway v1.5.0/go.mod h1:GpnZR3Q4rR7LVu5951qfXPJCHquZt02jf7xQx7kpqN8= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/apigeeconnect v1.5.0/go.mod h1:KFaCqvBRU6idyhSNyn3vlHXc8VMDJdRmwDF6JyFRqZ8= +cloud.google.com/go/apigeeregistry v0.4.0/go.mod h1:EUG4PGcsZvxOXAdyEghIdXwAEi/4MEaoqLMLDMIwKXY= +cloud.google.com/go/apigeeregistry v0.5.0/go.mod h1:YR5+s0BVNZfVOUkMa5pAR2xGd0A473vA5M7j247o1wM= +cloud.google.com/go/apigeeregistry v0.6.0/go.mod h1:BFNzW7yQVLZ3yj0TKcwzb8n25CFBri51GVGOEUcgQsc= +cloud.google.com/go/apikeys v0.4.0/go.mod h1:XATS/yqZbaBK0HOssf+ALHp8jAlNHUgyfprvNcBIszU= +cloud.google.com/go/apikeys v0.5.0/go.mod h1:5aQfwY4D+ewMMWScd3hm2en3hCj+BROlyrt3ytS7KLI= +cloud.google.com/go/apikeys v0.6.0/go.mod h1:kbpXu5upyiAlGkKrJgQl8A0rKNNJ7dQ377pdroRSSi8= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/appengine v1.6.0/go.mod h1:hg6i0J/BD2cKmDJbaFSYHFyZkgBEfQrDg/X0V5fJn84= +cloud.google.com/go/appengine v1.7.0/go.mod h1:eZqpbHFCqRGa2aCdope7eC0SWLV1j0neb/QnMJVWx6A= +cloud.google.com/go/appengine v1.7.1/go.mod h1:IHLToyb/3fKutRysUlFO0BPt5j7RiQ45nrzEJmKTo6E= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/area120 v0.7.0/go.mod h1:a3+8EUD1SX5RUcCs3MY5YasiO1z6yLiNLRiFrykbynY= +cloud.google.com/go/area120 v0.7.1/go.mod h1:j84i4E1RboTWjKtZVWXPqvK5VHQFJRF2c1Nm69pWm9k= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/artifactregistry v1.11.1/go.mod h1:lLYghw+Itq9SONbCa1YWBoWs1nOucMH0pwXN1rOBZFI= +cloud.google.com/go/artifactregistry v1.11.2/go.mod h1:nLZns771ZGAwVLzTX/7Al6R9ehma4WUEhZGWV6CeQNQ= +cloud.google.com/go/artifactregistry v1.12.0/go.mod h1:o6P3MIvtzTOnmvGagO9v/rOjjA0HmhJ+/6KAXrmYDCI= +cloud.google.com/go/artifactregistry v1.13.0/go.mod h1:uy/LNfoOIivepGhooAUpL1i30Hgee3Cu0l4VTWHUC08= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/asset v1.11.1/go.mod h1:fSwLhbRvC9p9CXQHJ3BgFeQNM4c9x10lqlrdEUYXlJo= +cloud.google.com/go/asset v1.12.0/go.mod h1:h9/sFOa4eDIyKmH6QMpm4eUK3pDojWnUhTgJlk762Hg= +cloud.google.com/go/asset v1.13.0/go.mod h1:WQAMyYek/b7NBpYq/K4KJWcRqzoalEsxz/t/dTk4THw= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/assuredworkloads v1.10.0/go.mod h1:kwdUQuXcedVdsIaKgKTp9t0UJkE5+PAVNhdQm4ZVq2E= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/automl v1.12.0/go.mod h1:tWDcHDp86aMIuHmyvjuKeeHEGq76lD7ZqfGLN6B0NuU= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= +cloud.google.com/go/beyondcorp v0.4.0/go.mod h1:3ApA0mbhHx6YImmuubf5pyW8srKnCEPON32/5hj+RmM= +cloud.google.com/go/beyondcorp v0.5.0/go.mod h1:uFqj9X+dSfrheVp7ssLTaRHd2EHqSL4QZmH4e8WXGGU= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= +cloud.google.com/go/bigquery v1.47.0/go.mod h1:sA9XOgy0A8vQK9+MWhEQTY6Tix87M/ZurWFIxmF9I/E= +cloud.google.com/go/bigquery v1.48.0/go.mod h1:QAwSz+ipNgfL5jxiaK7weyOhzdoAy1zFm0Nf1fysJac= +cloud.google.com/go/bigquery v1.49.0/go.mod h1:Sv8hMmTFFYBlt/ftw2uN6dFdQPzBlREY9yBh7Oy7/4Q= +cloud.google.com/go/bigquery v1.50.0/go.mod h1:YrleYEh2pSEbgTBZYMJ5SuSr0ML3ypjRB1zgf7pvQLU= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/billing v1.12.0/go.mod h1:yKrZio/eu+okO/2McZEbch17O5CB5NpZhhXG6Z766ss= +cloud.google.com/go/billing v1.13.0/go.mod h1:7kB2W9Xf98hP9Sr12KfECgfGclsH3CQR0R08tnRlRbc= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/binaryauthorization v1.5.0/go.mod h1:OSe4OU1nN/VswXKRBmciKpo9LulY41gch5c68htf3/Q= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/certificatemanager v1.6.0/go.mod h1:3Hh64rCKjRAX8dXgRAyOcY5vQ/fE1sh8o+Mdd6KPgY8= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/channel v1.11.0/go.mod h1:IdtI0uWGqhEeatSB62VOoJ8FSUhJ9/+iGkJVqp74CGE= +cloud.google.com/go/channel v1.12.0/go.mod h1:VkxCGKASi4Cq7TbXxlaBezonAYpp1GCnKMY6tnMQnLU= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/cloudbuild v1.6.0/go.mod h1:UIbc/w9QCbH12xX+ezUsgblrWv+Cv4Tw83GiSMHOn9M= +cloud.google.com/go/cloudbuild v1.7.0/go.mod h1:zb5tWh2XI6lR9zQmsm1VRA+7OCuve5d8S+zJUul8KTg= +cloud.google.com/go/cloudbuild v1.9.0/go.mod h1:qK1d7s4QlO0VwfYn5YuClDGg2hfmLZEb4wQGAbIgL1s= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/clouddms v1.5.0/go.mod h1:QSxQnhikCLUw13iAbffF2CZxAER3xDGNHjsTAkQJcQA= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/cloudtasks v1.9.0/go.mod h1:w+EyLsVkLWHcOaqNEyvcKAsWp9p29dL6uL9Nst1cI7Y= +cloud.google.com/go/cloudtasks v1.10.0/go.mod h1:NDSoTLkZ3+vExFEWu2UJV1arUyzVDAiZtdWcsUyNwBs= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute v1.18.0/go.mod h1:1X7yHxec2Ga+Ss6jPyjxRxpu2uu7PLgsOVXvgU0yacs= +cloud.google.com/go/compute v1.19.0/go.mod h1:rikpw2y+UMidAe9tISo04EHNOIf42RLYF/q8Bs93scU= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/contactcenterinsights v1.6.0/go.mod h1:IIDlT6CLcDoyv79kDv8iWxMSTZhLxSCofVV5W6YFM/w= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/container v1.13.1/go.mod h1:6wgbMPeQRw9rSnKBCAJXnds3Pzj03C4JHamr8asWKy4= +cloud.google.com/go/container v1.14.0/go.mod h1:3AoJMPhHfLDxLvrlVWaK57IXzaPnLaZq63WX59aQBfM= +cloud.google.com/go/container v1.15.0/go.mod h1:ft+9S0WGjAyjDggg5S06DXj+fHJICWg8L7isCQe9pQA= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/containeranalysis v0.7.0/go.mod h1:9aUL+/vZ55P2CXfuZjS4UjQ9AgXoSw8Ts6lemfmxBxI= +cloud.google.com/go/containeranalysis v0.9.0/go.mod h1:orbOANbwk5Ejoom+s+DUCTTJ7IBdBQJDcSylAx/on9s= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/datacatalog v1.8.1/go.mod h1:RJ58z4rMp3gvETA465Vg+ag8BGgBdnRPEMMSTr5Uv+M= +cloud.google.com/go/datacatalog v1.12.0/go.mod h1:CWae8rFkfp6LzLumKOnmVh4+Zle4A3NXLzVJ1d1mRm0= +cloud.google.com/go/datacatalog v1.13.0/go.mod h1:E4Rj9a5ZtAxcQJlEBTLgMTphfP11/lNaAshpoBgemX8= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataflow v0.8.0/go.mod h1:Rcf5YgTKPtQyYz8bLYhFoIV/vP39eL7fWNcSOyFfLJE= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/dataform v0.6.0/go.mod h1:QPflImQy33e29VuapFdf19oPbE4aYTJxr31OAPV+ulA= +cloud.google.com/go/dataform v0.7.0/go.mod h1:7NulqnVozfHvWUBpMDfKMUESr+85aJsC/2O0o3jWPDE= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datafusion v1.6.0/go.mod h1:WBsMF8F1RhSXvVM8rCV3AeyWVxcC2xY6vith3iw3S+8= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/datalabeling v0.7.0/go.mod h1:WPQb1y08RJbmpM3ww0CSUAGweL0SxByuW2E+FU+wXcM= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataplex v1.5.2/go.mod h1:cVMgQHsmfRoI5KFYq4JtIBEUbYwc3c7tXmIDhRmNNVQ= +cloud.google.com/go/dataplex v1.6.0/go.mod h1:bMsomC/aEJOSpHXdFKFGQ1b0TDPIeL28nJObeO1ppRs= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= +cloud.google.com/go/dataqna v0.7.0/go.mod h1:Lx9OcIIeqCrw1a6KdO3/5KMP1wAmTc0slZWwP12Qq3c= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastore v1.11.0/go.mod h1:TvGxBIHCS50u8jzG+AW/ppf87v1of8nwzFNgEZU1D3c= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/datastream v1.6.0/go.mod h1:6LQSuswqLa7S4rPAOZFVjHIG3wJIjZcZrw8JDEDJuIs= +cloud.google.com/go/datastream v1.7.0/go.mod h1:uxVRMm2elUSPuh65IbZpzJNMbuzkcvu5CjMqVIUHrww= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/deploy v1.6.0/go.mod h1:f9PTHehG/DjCom3QH0cntOVRm93uGBDt2vKzAPwpXQI= +cloud.google.com/go/deploy v1.8.0/go.mod h1:z3myEJnA/2wnB4sgjqdMfgxCA0EqC3RBTNcVPs93mtQ= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dialogflow v1.29.0/go.mod h1:b+2bzMe+k1s9V+F2jbJwpHPzrnIyHihAdRFMtn2WXuM= +cloud.google.com/go/dialogflow v1.31.0/go.mod h1:cuoUccuL1Z+HADhyIA7dci3N5zUssgpBJmCzI6fNRB4= +cloud.google.com/go/dialogflow v1.32.0/go.mod h1:jG9TRJl8CKrDhMEcvfcfFkkpp8ZhgPz3sBGmAUYJ2qE= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/dlp v1.9.0/go.mod h1:qdgmqgTyReTz5/YNSSuueR8pl7hO0o9bQ39ZhtgkWp4= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/documentai v1.16.0/go.mod h1:o0o0DLTEZ+YnJZ+J4wNfTxmDVyrkzFvttBXXtYRMHkM= +cloud.google.com/go/documentai v1.18.0/go.mod h1:F6CK6iUH8J81FehpskRmhLq/3VlwQvb7TvwOceQ2tbs= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/domains v0.8.0/go.mod h1:M9i3MMDzGFXsydri9/vW+EWz9sWb4I6WyHqdlAk0idE= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/edgecontainer v0.3.0/go.mod h1:FLDpP4nykgwwIfcLt6zInhprzw0lEi2P1fjO6Ie0qbc= +cloud.google.com/go/edgecontainer v1.0.0/go.mod h1:cttArqZpBB2q58W/upSG++ooo6EsblxDIolxa3jSjbY= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/essentialcontacts v1.5.0/go.mod h1:ay29Z4zODTuwliK7SnX8E86aUF2CTzdNtvv42niCX0M= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/eventarc v1.10.0/go.mod h1:u3R35tmZ9HvswGRBnF48IlYgYeBcPUCjkr4BTdem2Kw= +cloud.google.com/go/eventarc v1.11.0/go.mod h1:PyUjsUKPWoRBCHeOxZd/lbOOjahV41icXyUY5kSTvVY= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= +cloud.google.com/go/filestore v1.5.0/go.mod h1:FqBXDWBp4YLHqRnVGveOkHDf8svj9r5+mUDLupOWEDs= +cloud.google.com/go/filestore v1.6.0/go.mod h1:di5unNuss/qfZTw2U9nhFqo8/ZDSc466dre85Kydllg= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/functions v1.10.0/go.mod h1:0D3hEOe3DbEvCXtYOZHQZmD+SzYsi1YbI7dGvHfldXw= +cloud.google.com/go/functions v1.12.0/go.mod h1:AXWGrF3e2C/5ehvwYo/GH6O5s09tOPksiKhz+hH8WkA= +cloud.google.com/go/functions v1.13.0/go.mod h1:EU4O007sQm6Ef/PwRsI8N2umygGqPBS/IZQKBQBcJ3c= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gaming v1.9.0/go.mod h1:Fc7kEmCObylSWLO334NcO+O9QMDyz+TKC4v1D7X+Bc0= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkeconnect v0.7.0/go.mod h1:SNfmVqPkaEi3bF/B3CNZOAYPYdg7sU+obZ+QTky2Myw= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkehub v0.11.0/go.mod h1:JOWHlmN+GHyIbuWQPl47/C2RFhnFKH38jH9Ascu3n0E= +cloud.google.com/go/gkehub v0.12.0/go.mod h1:djiIwwzTTBrF5NaXCGv3mf7klpEMcST17VBTVVDcuaw= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/gkemulticloud v0.5.0/go.mod h1:W0JDkiyi3Tqh0TJr//y19wyb1yf8llHVto2Htf2Ja3Y= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/gsuiteaddons v1.5.0/go.mod h1:TFCClYLd64Eaa12sFVmUyG62tk4mdIsI7pAnSXRkcFo= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iam v0.11.0/go.mod h1:9PiLDanza5D+oWFZiH1uG+RnRCfEGKoyl6yo4cgWZGY= +cloud.google.com/go/iam v0.12.0/go.mod h1:knyHGviacl11zrtZUoDuYpDgLjvr28sLQaG0YB2GYAY= +cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/iap v1.6.0/go.mod h1:NSuvI9C/j7UdjGjIde7t7HBz+QTwBcapPE07+sSRcLk= +cloud.google.com/go/iap v1.7.0/go.mod h1:beqQx56T9O1G1yNPph+spKpNibDlYIiIixiqsQXxLIo= +cloud.google.com/go/iap v1.7.1/go.mod h1:WapEwPc7ZxGt2jFGB/C/bm+hP0Y6NXzOYGjpPnmMS74= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/ids v1.3.0/go.mod h1:JBdTYwANikFKaDP6LtW5JAi4gubs57SVNQjemdt6xV4= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/iot v1.5.0/go.mod h1:mpz5259PDl3XJthEmh9+ap0affn/MqNSP4My77Qql9o= +cloud.google.com/go/iot v1.6.0/go.mod h1:IqdAsmE2cTYYNO1Fvjfzo9po179rAtJeVGUvkLN3rLE= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/kms v1.8.0/go.mod h1:4xFEhYFqvW+4VMELtZyxomGSYtSQKzM178ylFW4jMAg= +cloud.google.com/go/kms v1.9.0/go.mod h1:qb1tPTgfF9RQP8e1wq4cLFErVuTJv7UsSC915J8dh3w= +cloud.google.com/go/kms v1.10.0/go.mod h1:ng3KTUtQQU9bPX3+QGLsflZIHlkbn8amFAMY63m8d24= +cloud.google.com/go/kms v1.10.1/go.mod h1:rIWk/TryCkR59GMC3YtHtXeLzd634lBbKenvyySAyYI= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/language v1.9.0/go.mod h1:Ns15WooPM5Ad/5no/0n81yUetis74g3zrbeJBE+ptUY= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/maps v0.6.0/go.mod h1:o6DAMMfb+aINHz/p/jbcY+mYeXBoZoxTfdSQ8VAJaCw= +cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/mediatranslation v0.7.0/go.mod h1:LCnB/gZr90ONOIQLgSXagp8XUW1ODs2UmUMvcgMfI2I= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/memcache v1.9.0/go.mod h1:8oEyzXCu+zo9RzlEaEjHl4KkgjlNDaXbCQeQWlzNFJM= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/metastore v1.10.0/go.mod h1:fPEnH3g4JJAk+gMRnrAnoqyv2lpUCqJPWOodSaf45Eo= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/monitoring v1.12.0/go.mod h1:yx8Jj2fZNEkL/GYZyTLS4ZtZEZN8WtDEiEqG4kLK50w= +cloud.google.com/go/monitoring v1.13.0/go.mod h1:k2yMBAB1H9JT/QETjNkgdCGD9bPF712XiLTVr+cBrpw= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkconnectivity v1.10.0/go.mod h1:UP4O4sWXJG13AqrTdQCD9TnLGEbtNRqjuaaA7bNjF5E= +cloud.google.com/go/networkconnectivity v1.11.0/go.mod h1:iWmDD4QF16VCDLXUqvyspJjIEtBR/4zq5hwnY2X3scM= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networkmanagement v1.6.0/go.mod h1:5pKPqyXjB/sgtvB5xqOemumoQNB7y95Q7S+4rjSOPYY= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/networksecurity v0.7.0/go.mod h1:mAnzoxx/8TBSyXEeESMy9OOYwo1v+gZ5eMRnsT5bC8k= +cloud.google.com/go/networksecurity v0.8.0/go.mod h1:B78DkqsxFG5zRSVuwYFRZ9Xz8IcQ5iECsNrPn74hKHU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/notebooks v1.7.0/go.mod h1:PVlaDGfJgj1fl1S3dUwhFMXFgfYGhYQt2164xOMONmE= +cloud.google.com/go/notebooks v1.8.0/go.mod h1:Lq6dYKOYOWUCTvw5t2q1gp1lAp0zxAxRycayS0iJcqQ= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/optimization v1.3.1/go.mod h1:IvUSefKiwd1a5p0RgHDbWCIbDFgKuEdB+fPPuP0IDLI= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orchestration v1.6.0/go.mod h1:M62Bevp7pkxStDfFfTuCOaXgaaqRAga1yKyoMtEoWPQ= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/orgpolicy v1.10.0/go.mod h1:w1fo8b7rRqlXlIJbVhOMPrwVljyuW5mqssvBtU18ONc= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/osconfig v1.11.0/go.mod h1:aDICxrur2ogRd9zY5ytBLV89KEgT2MKB2L/n6x1ooPw= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/oslogin v1.9.0/go.mod h1:HNavntnH8nzrn8JCTT5fj18FuJLFJc4NaZJtBnQtKFs= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/phishingprotection v0.7.0/go.mod h1:8qJI4QKHoda/sb/7/YmMQ2omRLSLYSu9bU0EKCNI+Lk= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/policytroubleshooter v1.5.0/go.mod h1:Rz1WfV+1oIpPdN2VvvuboLVRsB1Hclg3CKQ53j9l8vw= +cloud.google.com/go/policytroubleshooter v1.6.0/go.mod h1:zYqaPTsmfvpjm5ULxAyD/lINQxJ0DDsnWOP/GZ7xzBc= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= +cloud.google.com/go/privatecatalog v0.7.0/go.mod h1:2s5ssIFO69F5csTXcwBP7NPFTZvps26xGzvQ2PQaBYg= +cloud.google.com/go/privatecatalog v0.8.0/go.mod h1:nQ6pfaegeDAq/Q5lrfCQzQLhubPiZhSaNhIgfJlnIXs= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsub v1.28.0/go.mod h1:vuXFpwaVoIPQMGXqRyUQigu/AX1S3IWugR9xznmcXX8= +cloud.google.com/go/pubsub v1.30.0/go.mod h1:qWi1OPS0B+b5L+Sg6Gmc9zD1Y+HaM0MdUr7LsupY1P4= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/pubsublite v1.6.0/go.mod h1:1eFCS0U11xlOuMFV/0iBqw3zP12kddMeCbj/F3FSj9k= +cloud.google.com/go/pubsublite v1.7.0/go.mod h1:8hVMwRXfDfvGm3fahVbtDbiLePT3gpoiJYJY+vxWxVM= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recaptchaenterprise/v2 v2.6.0/go.mod h1:RPauz9jeLtB3JVzg6nCbe12qNoaa8pXc4d/YukAmcnA= +cloud.google.com/go/recaptchaenterprise/v2 v2.7.0/go.mod h1:19wVj/fs5RtYtynAPJdDTb69oW0vNHYDBTbB4NvMD9c= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommendationengine v0.7.0/go.mod h1:1reUcE3GIu6MeBz/h5xZJqNLuuVjNg1lmWMPyjatzac= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/recommender v1.9.0/go.mod h1:PnSsnZY7q+VL1uax2JWkt/UegHssxjUVVCrX52CuEmQ= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/redis v1.11.0/go.mod h1:/X6eicana+BWcUda5PpwZC48o37SiFVTFSs0fWAJ7uQ= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcemanager v1.5.0/go.mod h1:eQoXNAiAvCf5PXxWxXjhKQoTMaUSNrEfg+6qdf/wots= +cloud.google.com/go/resourcemanager v1.6.0/go.mod h1:YcpXGRs8fDzcUl1Xw8uOVmI8JEadvhRIkoXXUNVYcVo= +cloud.google.com/go/resourcemanager v1.7.0/go.mod h1:HlD3m6+bwhzj9XCouqmeiGuni95NTrExfhoSrkC/3EI= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/resourcesettings v1.5.0/go.mod h1:+xJF7QSG6undsQDfsCJyqWXyBwUoJLhetkRMDRnIoXA= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/retail v1.12.0/go.mod h1:UMkelN/0Z8XvKymXFbD4EhFJlYKRx1FGhQkVPU5kF14= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/run v0.8.0/go.mod h1:VniEnuBwqjigv0A7ONfQUaEItaiCRVujlMqerPPiktM= +cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/scheduler v1.8.0/go.mod h1:TCET+Y5Gp1YgHT8py4nlg2Sew8nUHMqcpousDgXJVQc= +cloud.google.com/go/scheduler v1.9.0/go.mod h1:yexg5t+KSmqu+njTIh3b7oYPheFtBWGcbVUYF1GGMIc= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/secretmanager v1.10.0/go.mod h1:MfnrdvKMPNra9aZtQFvBcvRU54hbPD8/HayQdlUgJpU= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/security v1.12.0/go.mod h1:rV6EhrpbNHrrxqlvW0BWAIawFWq3X90SduMJdFwtLB8= +cloud.google.com/go/security v1.13.0/go.mod h1:Q1Nvxl1PAgmeW0y3HTt54JYIvUdtcpYKVfIB8AOMZ+0= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/securitycenter v1.18.1/go.mod h1:0/25gAzCM/9OL9vVx4ChPeM/+DlfGQJDwBy/UC8AKK0= +cloud.google.com/go/securitycenter v1.19.0/go.mod h1:LVLmSg8ZkkyaNy4u7HCIshAngSQ8EcIRREP3xBnyfag= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicecontrol v1.10.0/go.mod h1:pQvyvSRh7YzUF2efw7H87V92mxU8FnFDawMClGCNuAA= +cloud.google.com/go/servicecontrol v1.11.0/go.mod h1:kFmTzYzTUIuZs0ycVqRHNaNhgR+UMUpw9n02l/pY+mc= +cloud.google.com/go/servicecontrol v1.11.1/go.mod h1:aSnNNlwEFBY+PWGQ2DoM0JJ/QUXqV5/ZD9DOLB7SnUk= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicedirectory v1.8.0/go.mod h1:srXodfhY1GFIPvltunswqXpVxFPpZjf8nkKQT7XcXaY= +cloud.google.com/go/servicedirectory v1.9.0/go.mod h1:29je5JjiygNYlmsGz8k6o+OZ8vd4f//bQLtvzkPPT/s= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/servicemanagement v1.6.0/go.mod h1:aWns7EeeCOtGEX4OvZUWCCJONRZeFKiptqKf1D0l/Jc= +cloud.google.com/go/servicemanagement v1.8.0/go.mod h1:MSS2TDlIEQD/fzsSGfCdJItQveu9NXnUniTrq/L8LK4= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/serviceusage v1.5.0/go.mod h1:w8U1JvqUqwJNPEOTQjrMHkw3IaIFLoLsPLvsE3xueec= +cloud.google.com/go/serviceusage v1.6.0/go.mod h1:R5wwQcbOWsyuOfbP9tGdAnCAc6B9DRwPG1xtWMDeuPA= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/shell v1.6.0/go.mod h1:oHO8QACS90luWgxP3N9iZVuEiSF84zNyLytb+qE2f9A= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/spanner v1.44.0/go.mod h1:G8XIgYdOK+Fbcpbs7p2fiprDw4CaZX63whnSMLVBxjk= +cloud.google.com/go/spanner v1.45.0/go.mod h1:FIws5LowYz8YAE1J8fOS7DJup8ff7xJeetWEo5REA2M= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= +cloud.google.com/go/speech v1.14.1/go.mod h1:gEosVRPJ9waG7zqqnsHpYTOoAS4KouMRLDFMekpJ0J0= +cloud.google.com/go/speech v1.15.0/go.mod h1:y6oH7GhqCaZANH7+Oe0BhgIogsNInLlz542tg3VqeYI= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= +cloud.google.com/go/storage v1.29.0/go.mod h1:4puEjyTKnku6gfKoTfNOU/W+a9JyuVNxjpS5GBrB8h4= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/storagetransfer v1.7.0/go.mod h1:8Giuj1QNb1kfLAiWM1bN6dHzfdlDAVC9rv9abHot2W4= +cloud.google.com/go/storagetransfer v1.8.0/go.mod h1:JpegsHHU1eXg7lMHkvf+KE5XDJ7EQu0GwNJbbVGanEw= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/talent v1.5.0/go.mod h1:G+ODMj9bsasAEJkQSzO2uHQWXHHXUomArjWQQYkqK6c= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/texttospeech v1.6.0/go.mod h1:YmwmFT8pj1aBblQOI3TfKmwibnsfvhIBzPXcW4EBovc= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/tpu v1.5.0/go.mod h1:8zVo1rYDFuW2l4yZVY0R0fb/v44xLh3llq7RuV61fPM= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/trace v1.8.0/go.mod h1:zH7vcsbAhklH8hWFig58HvxcxyQbaIqMarMg9hn5ECA= +cloud.google.com/go/trace v1.9.0/go.mod h1:lOQqpE5IaWY0Ixg7/r2SjixMuc6lfTFeO4QGM4dQWOk= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/translate v1.5.0/go.mod h1:29YDSYveqqpA1CQFD7NQuP49xymq17RXNaUDdc0mNu0= +cloud.google.com/go/translate v1.6.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/translate v1.7.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/video v1.12.0/go.mod h1:MLQew95eTuaNDEGriQdcYn0dTwf9oWiA4uYebxM5kdg= +cloud.google.com/go/video v1.13.0/go.mod h1:ulzkYlYgCp15N2AokzKjy7MQ9ejuynOJdf1tR5lGthk= +cloud.google.com/go/video v1.14.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/video v1.15.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/videointelligence v1.10.0/go.mod h1:LHZngX1liVtUhZvi2uNS0VQuOzNi2TkY1OakiuoUOjU= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vision/v2 v2.6.0/go.mod h1:158Hes0MvOS9Z/bDMSFpjwsUrZ5fPrdwuyyvKSGAGMY= +cloud.google.com/go/vision/v2 v2.7.0/go.mod h1:H89VysHy21avemp6xcf9b9JvZHVehWbET0uT/bcuY/0= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmmigration v1.5.0/go.mod h1:E4YQ8q7/4W9gobHjQg4JJSgXXSgY21nA5r8swQV+Xxc= +cloud.google.com/go/vmmigration v1.6.0/go.mod h1:bopQ/g4z+8qXzichC7GW1w2MjbErL54rk3/C843CjfY= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vmwareengine v0.2.2/go.mod h1:sKdctNJxb3KLZkE/6Oui94iw/xs9PRNC2wnNLXsHvH8= +cloud.google.com/go/vmwareengine v0.3.0/go.mod h1:wvoyMvNWdIzxMYSpH/R7y2h5h3WFkx6d+1TIsP39WGY= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/vpcaccess v1.6.0/go.mod h1:wX2ILaNhe7TlVa4vC5xce1bCnqE3AeH27RV31lnmZes= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/webrisk v1.8.0/go.mod h1:oJPDuamzHXgUc+b8SiHRcVInZQuybnvEW72PqTc7sSg= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/websecurityscanner v1.5.0/go.mod h1:Y6xdCPy81yi0SQnDY1xdNTNpfY1oAgXUlcfN3B3eSng= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= +cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcPALq2CxzdePw= +dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s= +dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +gioui.org v0.0.0-20210308172011-57750fc8a0a6/go.mod h1:RSH6KIUZ0p2xy5zHDxgAM4zumjgTw83q2ge/PI+yyw8= +git.sr.ht/~sbinet/gg v0.3.1/go.mod h1:KGYtlADtqsqANL9ueOFkWymvzUvLMQllU5Ixo+8v3pc= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg= +github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= +github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI= +github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= +github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0= +github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= +github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs= +github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0= +github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/Microsoft/hcsshim v0.11.7 h1:vl/nj3Bar/CvJSYo7gIQPyRWc9f3c6IeSNavBTSZNZQ= +github.com/Microsoft/hcsshim v0.11.7/go.mod h1:MV8xMfmECjl5HdO7U/3/hFVnkmSBjAjmA09d4bExKcU= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw= +github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/ajstarks/deck v0.0.0-20200831202436-30c9fc6549a9/go.mod h1:JynElWSGnm/4RlzPXRlREEwqTHAN3T56Bv2ITsFT3gY= +github.com/ajstarks/deck/generate v0.0.0-20210309230005-c3f852c02e19/go.mod h1:T13YZdzov6OU0A1+RfKZiZN9ca6VeKdBdyDV+BY97Tk= +github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= +github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apache/arrow/go/v10 v10.0.1/go.mod h1:YvhnlEePVnBS4+0z3fhPfUy7W1Ikj0Ih0vcRo/gZ1M0= +github.com/apache/arrow/go/v11 v11.0.0/go.mod h1:Eg5OsL5H+e299f7u5ssuXsuHQVEGC4xei5aX110hRiI= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= +github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/boombuler/barcode v1.0.1/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/bshuster-repo/logrus-logstash-hook v1.0.0 h1:e+C0SB5R1pu//O4MQ3f9cFuPGoOVeF2fE4Og9otCc70= +github.com/bshuster-repo/logrus-logstash-hook v1.0.0/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk= +github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= +github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM= +github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw= +github.com/containerd/containerd v1.7.30 h1:/2vezDpLDVGGmkUXmlNPLCCNKHJ5BbC5tJB5JNzQhqE= +github.com/containerd/containerd v1.7.30/go.mod h1:fek494vwJClULlTpExsmOyKCMUAbuVjlFsJQc4/j44M= +github.com/containerd/continuity v0.4.4 h1:/fNVfTJ7wIl/YPMHjf+5H32uFhl63JucB34PlCpMKII= +github.com/containerd/continuity v0.4.4/go.mod h1:/lNJvtJKUQStBzpVQ1+rasXO1LAWtUQssk28EZvJ3nE= +github.com/containerd/errdefs v0.3.0 h1:FSZgGOeK4yuT/+DnF07/Olde/q4KBoMsaamhXxIMDp4= +github.com/containerd/errdefs v0.3.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A= +github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw= +github.com/containerd/stargz-snapshotter/estargz v0.14.3 h1:OqlDCK3ZVUO6C3B/5FSkDwbkEETK84kQgEeFwDC+62k= +github.com/containerd/stargz-snapshotter/estargz v0.14.3/go.mod h1:KY//uOCIkSuNAHhJogcZtrNHdKrA99/FCCRjE3HD36o= +github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/cyphar/filepath-securejoin v0.5.1 h1:eYgfMq5yryL4fbWfkLpFFy2ukSELzaJOTaUTuh+oF48= +github.com/cyphar/filepath-securejoin v0.5.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/distribution/distribution/v3 v3.0.0 h1:q4R8wemdRQDClzoNNStftB2ZAfqOiN6UX90KJc4HjyM= +github.com/distribution/distribution/v3 v3.0.0/go.mod h1:tRNuFoZsUdyRVegq8xGNeds4KLjwLCRin/tTo6i1DhU= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI= +github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/docker/cli v28.5.1+incompatible h1:ESutzBALAD6qyCLqbQSEf1a/U8Ybms5agw59yGVc+yY= +github.com/docker/cli v28.5.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk= +github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= +github.com/docker/docker v28.5.1+incompatible h1:Bm8DchhSD2J6PsFzxC35TZo4TLGR2PdW/E69rU45NhM= +github.com/docker/docker v28.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/docker-credential-helpers v0.8.2 h1:bX3YxiGzFP5sOXWc3bTPEXdEaZSeVMrFgOr3T+zrFAo= +github.com/docker/docker-credential-helpers v0.8.2/go.mod h1:P3ci7E3lwkZg6XiHdRKft1KckHiO9a2rNtyFbZ/ry9M= +github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94= +github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE= +github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c h1:+pKlWGMw7gf6bQ+oDZB4KHQFypsfjYlq/C4rfL7D3g8= +github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA= +github.com/docker/go-metrics v0.0.1 h1:AgB/0SvBxihN0X8OR4SjsblXkbMvalQ8cjmtKQ2rQV8= +github.com/docker/go-metrics v0.0.1/go.mod h1:cG1hvH2utMXtqgqqYE9plW6lDxS3/5ayHzueweSI3Vw= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE= +github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= +github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= +github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g= +github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= +github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= +github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU= +github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/flowstack/go-jsonschema v0.1.1/go.mod h1:yL7fNggx1o8rm9RlgXv7hTBWxdBM0rVwpMwimd3F3N0= +github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E= +github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-fonts/dejavu v0.1.0/go.mod h1:4Wt4I4OU2Nq9asgDCteaAaWZOV24E+0/Pwo0gppep4g= +github.com/go-fonts/latin-modern v0.2.0/go.mod h1:rQVLdDMK+mK1xscDwsqM5J8U2jrRa3T0ecnM9pNujks= +github.com/go-fonts/liberation v0.1.1/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/liberation v0.2.0/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/stix v0.1.0/go.mod h1:w/c1f0ldAUlJmLBvlbkvVXLAD+tAMqobIIQpmnUIzUY= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= +github.com/go-git/go-billy/v5 v5.8.0 h1:I8hjc3LbBlXTtVuFNJuwYuMiHvQJDq1AT6u4DwDzZG0= +github.com/go-git/go-billy/v5 v5.8.0/go.mod h1:RpvI/rw4Vr5QA+Z60c6d6LXH0rYJo0uD5SqfmrrheCY= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= +github.com/go-git/go-git/v5 v5.17.1 h1:WnljyxIzSj9BRRUlnmAU35ohDsjRK0EKmL0evDqi5Jk= +github.com/go-git/go-git/v5 v5.17.1/go.mod h1:pW/VmeqkanRFqR6AljLcs7EA7FbZaN5MQqO7oZADXpo= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-latex/latex v0.0.0-20210118124228-b3d85cf34e07/go.mod h1:CO1AlKB2CSIqUrmQPqA0gdRIlnLEY0gK5JGjh37zN5U= +github.com/go-latex/latex v0.0.0-20210823091927-c0d11ff05a81/go.mod h1:SX0U8uGpxhq9o2S/CELCSUxEWWAuoCUcVCQWv7G2OCk= +github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs= +github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= +github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= +github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE= +github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k= +github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= +github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= +github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= +github.com/go-pdf/fpdf v0.5.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-pdf/fpdf v0.6.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= +github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= +github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/gnostic v0.7.0 h1:d7EpuFp8vVdML+y0JJJYiKeOLjKTdH/GvVkLOBWqJpw= +github.com/google/gnostic v0.7.0/go.mod h1:IAcUyMl6vtC95f60EZ8oXyqTsOersP6HbwjeG7EyDPM= +github.com/google/gnostic-models v0.6.9-0.20230804172637-c7be7c783f49/go.mod h1:BkkQ4L1KS1xMt2aWSPStnn55ChGC0DPOn2FQYj+f25M= +github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw= +github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-containerregistry v0.14.0 h1:z58vMqHxuwvAsVwvKEkmVBz2TlgBgH5k6koEXBtlYkw= +github.com/google/go-containerregistry v0.14.0/go.mod h1:aiJ2fp/SXvkWgmYHioXnbMdlgB8eXiiYOY55gfN91Wk= +github.com/google/go-jsonnet v0.22.0 h1:o0bOAIE+9SIfRZ7FXQPuta0mHLLE0AwbY/L5GTH5CH8= +github.com/google/go-jsonnet v0.22.0/go.mod h1:pLhKpu0/ODjL2Zev4y+CmCoHKAgONT1gSLQyriuYh9w= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= +github.com/googleapis/enterprise-certificate-proxy v0.2.1/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE= +github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0 h1:TmHmbvxPmaegwhDubVz0lICL0J5Ka2vwTzhoePEXsGE= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0/go.mod h1:qztMSjm835F2bXf+5HKAPIS5qsmQDqZna/PgVt4rWtI= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru/arc/v2 v2.0.5 h1:l2zaLDubNhW4XO3LnliVj0GXO3+/CGNJAg1dcN2Fpfw= +github.com/hashicorp/golang-lru/arc/v2 v2.0.5/go.mod h1:ny6zBSQZi2JxIeYcv7kt2sH2PXJtirBN7RDhRpxPkxU= +github.com/hashicorp/golang-lru/v2 v2.0.5 h1:wW7h1TG88eUIJ2i69gaE3uNVtEPIagzhGvHgwfx2Vm4= +github.com/hashicorp/golang-lru/v2 v2.0.5/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= +github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI= +github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= +github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= +github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= +github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kubecfg/ursonnet v0.1.1 h1:D8IsJFGryLCYDYx+v/qMOCsOrH9NCLUYiuilppkisH8= +github.com/kubecfg/ursonnet v0.1.1/go.mod h1:3tCiatkU+90PIexhvZDG00ISgIB7U9fM0oPAqn/jamg= +github.com/kubecfg/yaml/v2 v2.4.2 h1:eyCOIzzAX1FEf9lcDOsIvUX+oBVm9bHlg9vVHhBCEVY= +github.com/kubecfg/yaml/v2 v2.4.2/go.mod h1:z1eemV0tke+0kjM/5OLgul7hO2/YXxbWV5UFNWYKfvI= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/moby/locker v1.0.1 h1:fOXqR41zeveg4fFODix+1Ch4mj/gT0NE1XJbp/epuBg= +github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc= +github.com/moby/sys/mountinfo v0.6.2 h1:BzJjoreD5BMFNmD9Rus6gdd1pLuecOFPt8wC+Vygl78= +github.com/moby/sys/mountinfo v0.6.2/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI= +github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= +github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/onsi/ginkgo/v2 v2.21.0 h1:7rg/4f3rB88pb5obDgNZrNHrQ4e6WpjonchcpuBRnZM= +github.com/onsi/ginkgo/v2 v2.21.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo= +github.com/onsi/gomega v1.35.1 h1:Cwbd75ZBPxFSuZ6T+rN/WCb/gOc6YgFBXLlZLhC7Ds4= +github.com/onsi/gomega v1.35.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= +github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5 h1:Ii+DKncOVM8Cu1Hc+ETb5K+23HdAMvESYE3ZJ5b5cMI= +github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5/go.mod h1:iIss55rKnNBTvrwdmkUpLnDpZoAHvWaiq5+iMmen4AE= +github.com/phpdave11/gofpdf v1.4.2/go.mod h1:zpO6xFn9yxo3YLyMvW8HcKWVdbNqgIfOOp2dXMnm1mY= +github.com/phpdave11/gofpdi v1.0.12/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/phpdave11/gofpdi v1.0.13/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4= +github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g= +github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q= +github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc= +github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io= +github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I= +github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5 h1:EaDatTxkdHG+U3Bk4EUr+DZ7fOGwTfezUiUJMaIcaho= +github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5/go.mod h1:fyalQWdtzDBECAQFBJuQe5bzQ02jGd5Qcbgb97Flm7U= +github.com/redis/go-redis/extra/redisotel/v9 v9.0.5 h1:EfpWLLCyXw8PSM2/XNJLjI3Pb27yVE+gIAfeqp8LUCc= +github.com/redis/go-redis/extra/redisotel/v9 v9.0.5/go.mod h1:WZjPDy7VNzn77AAfnAfVjZNvfJTYfPetfZk5yoSTLaQ= +github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM= +github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= +github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w= +github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZKsJ8yyVxGRWYNEm9oFB8ieLgKFnamEyDmSA0BRk= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY= +github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ= +github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= +github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= +github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8= +github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w= +github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s= +github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0= +github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY= +github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ= +github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk= +github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/vbatts/tar-split v0.11.2 h1:Via6XqJr0hceW4wff3QRzD5gAk/tatMw/4ZA7cTlIME= +github.com/vbatts/tar-split v0.11.2/go.mod h1:vV3ZuO2yWSVsz+pfFzDG/upWH1JhjOiEaWq6kXyQ3VI= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= +github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ= +github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/contrib/bridges/prometheus v0.57.0 h1:UW0+QyeyBVhn+COBec3nGhfnFe5lwB0ic1JBVjzhk0w= +go.opentelemetry.io/contrib/bridges/prometheus v0.57.0/go.mod h1:ppciCHRLsyCio54qbzQv0E4Jyth/fLWDTJYfvWpcSVk= +go.opentelemetry.io/contrib/exporters/autoexport v0.57.0 h1:jmTVJ86dP60C01K3slFQa2NQ/Aoi7zA+wy7vMOKD9H4= +go.opentelemetry.io/contrib/exporters/autoexport v0.57.0/go.mod h1:EJBheUMttD/lABFyLXhce47Wr6DPWYReCzaZiXadH7g= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 h1:yd02MEjBdJkG3uabWP9apV+OuWRIXGDuJEUJbOHmCFU= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0/go.mod h1:umTcuxiv1n/s/S6/c2AT/g2CQ7u5C59sHDNmfSwgz7Q= +go.opentelemetry.io/otel v1.33.0 h1:/FerN9bax5LoK51X/sI0SVYrjSE0/yUL7DpxW4K3FWw= +go.opentelemetry.io/otel v1.33.0/go.mod h1:SUUkR6csvUQl+yjReHu5uM3EtVV7MBm5FHKRlNx4I8I= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.8.0 h1:WzNab7hOOLzdDF/EoWCt4glhrbMPVMOO5JYTmpz36Ls= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.8.0/go.mod h1:hKvJwTzJdp90Vh7p6q/9PAOd55dI6WA6sWj62a/JvSs= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.8.0 h1:S+LdBGiQXtJdowoJoQPEtI52syEP/JYBUpjO49EQhV8= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.8.0/go.mod h1:5KXybFvPGds3QinJWQT7pmXf+TN5YIa7CNYObWRkj50= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.32.0 h1:j7ZSD+5yn+lo3sGV69nW04rRR0jhYnBwjuX3r0HvnK0= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.32.0/go.mod h1:WXbYJTUaZXAbYd8lbgGuvih0yuCfOFC5RJoYnoLcGz8= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.32.0 h1:t/Qur3vKSkUCcDVaSumWF2PKHt85pc7fRvFuoVT8qFU= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.32.0/go.mod h1:Rl61tySSdcOJWoEgYZVtmnKdA0GeKrSqkHC1t+91CH8= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0 h1:Vh5HayB/0HHfOQA7Ctx69E/Y/DcQSMPpKANYVMQ7fBA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0/go.mod h1:cpgtDBaqD/6ok/UG0jT15/uKjAY8mRA53diogHBg3UI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0 h1:5pojmb1U1AogINhN3SurB+zm/nIcusopeBNp42f45QM= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0/go.mod h1:57gTHJSE5S1tqg+EKsLPlTWhpHMsWlVmer+LA926XiA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.32.0 h1:cMyu9O88joYEaI47CnQkxO1XZdpoTF9fEnW2duIddhw= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.32.0/go.mod h1:6Am3rn7P9TVVeXYG+wtcGE7IE1tsQ+bP3AuWcKt/gOI= +go.opentelemetry.io/otel/exporters/prometheus v0.54.0 h1:rFwzp68QMgtzu9PgP3jm9XaMICI6TsofWWPcBDKwlsU= +go.opentelemetry.io/otel/exporters/prometheus v0.54.0/go.mod h1:QyjcV9qDP6VeK5qPyKETvNjmaaEc7+gqjh4SS0ZYzDU= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.8.0 h1:CHXNXwfKWfzS65yrlB2PVds1IBZcdsX8Vepy9of0iRU= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.8.0/go.mod h1:zKU4zUgKiaRxrdovSS2amdM5gOc59slmo/zJwGX+YBg= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.32.0 h1:SZmDnHcgp3zwlPBS2JX2urGYe/jBKEIT6ZedHRUyCz8= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.32.0/go.mod h1:fdWW0HtZJ7+jNpTKUR0GpMEDP69nR8YBJQxNiVCE3jk= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.32.0 h1:cC2yDI3IQd0Udsux7Qmq8ToKAx1XCilTQECZ0KDZyTw= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.32.0/go.mod h1:2PD5Ex6z8CFzDbTdOlwyNIUywRr1DN0ospafJM1wJ+s= +go.opentelemetry.io/otel/log v0.8.0 h1:egZ8vV5atrUWUbnSsHn6vB8R21G2wrKqNiDt3iWertk= +go.opentelemetry.io/otel/log v0.8.0/go.mod h1:M9qvDdUTRCopJcGRKg57+JSQ9LgLBrwwfC32epk5NX8= +go.opentelemetry.io/otel/metric v1.33.0 h1:r+JOocAyeRVXD8lZpjdQjzMadVZp2M4WmQ+5WtEnklQ= +go.opentelemetry.io/otel/metric v1.33.0/go.mod h1:L9+Fyctbp6HFTddIxClbQkjtubW6O9QS3Ann/M82u6M= +go.opentelemetry.io/otel/sdk v1.33.0 h1:iax7M131HuAm9QkZotNHEfstof92xM+N8sr3uHXc2IM= +go.opentelemetry.io/otel/sdk v1.33.0/go.mod h1:A1Q5oi7/9XaMlIWzPSxLRWOI8nG3FnzHJNbiENQuihM= +go.opentelemetry.io/otel/sdk/log v0.8.0 h1:zg7GUYXqxk1jnGF/dTdLPrK06xJdrXgqgFLnI4Crxvs= +go.opentelemetry.io/otel/sdk/log v0.8.0/go.mod h1:50iXr0UVwQrYS45KbruFrEt4LvAdCaWWgIrsN3ZQggo= +go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU= +go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ= +go.opentelemetry.io/otel/trace v1.33.0 h1:cCJuF7LRjUFso9LPnEAHJDB2pqzp+hbO8eu1qqW2d/s= +go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck= +go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= +go.opentelemetry.io/proto/otlp v1.4.0 h1:TA9WRvW6zMwP+Ssb6fLoUIuirti1gGbP28GcKG1jgeg= +go.opentelemetry.io/proto/otlp v1.4.0/go.mod h1:PPBWZIP98o2ElSqI35IHfu7hIhSwvc5N38Jw8pXuGFY= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= +go.yaml.in/yaml/v3 v3.0.3 h1:bXOww4E/J3f66rav3pX3m8w6jDE4knZjGOw8b5Y6iNE= +go.yaml.in/yaml/v3 v3.0.3/go.mod h1:tBHosrYAkRZjRAOREWbDnBXUf08JOwYq++0QNwQiWzI= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q= +golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4= +golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3/go.mod h1:NOZ3BPKG0ec/BKJQgnvsSFpcKLM5xXVWnvZS97DWHgE= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20201208152932-35266b937fa6/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210216034530-4410531fe030/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210607152325-775e3b0c77b9/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20220302094943-723b81ca9867/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY= +golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= +golang.org/x/oauth2 v0.5.0/go.mod h1:9/XBHVqLaWO3/BRHs5jbpYCnOZVjj5V0ndyaAM7KB4I= +golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= +golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI= +golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= +golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210304124612-50617c2ba197/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc= +golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU= +golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= +golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= +golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= +golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190927191325-030b2cf1153e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ= +golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= +gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= +gonum.org/v1/gonum v0.9.3/go.mod h1:TZumC3NeyVQskjXqmyWt4S3bINhy7B4eYwW69EbyX+0= +gonum.org/v1/gonum v0.11.0/go.mod h1:fSG4YDCxxUZQJ7rKsQrj0gMOg00Il0Z96/qMA4bVQhA= +gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= +gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= +gonum.org/v1/plot v0.9.0/go.mod h1:3Pcqqmp6RHvJI72kgb8fThyUnav364FOsdDo2aGW5lY= +gonum.org/v1/plot v0.10.1/go.mod h1:VZW5OlhkL1mysU9vaqNHnsy86inf6Ot+jB3r+BczCEo= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= +google.golang.org/api v0.106.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.107.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.108.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.110.0/go.mod h1:7FC4Vvx1Mooxh8C5HWjzZHcavuS2f6pmJpZx60ca7iI= +google.golang.org/api v0.111.0/go.mod h1:qtFHvU9mhgTJegR31csQ+rwxyUTHOKFqCKWp1J0fdw0= +google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221109142239-94d6d90a7d66/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201204527-e3fa12d562f3/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230112194545-e10362b5ecf9/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230113154510-dbe35b8444a5/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230123190316-2c411cf9d197/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230125152338-dcaf20b6aeaa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230127162408-596548ed4efa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230216225411-c8e22ba71e44/go.mod h1:8B0gmkoRebU8ukX6HP+4wrVQUY1+6PkQ44BSyIlflHA= +google.golang.org/genproto v0.0.0-20230222225845-10f96fb3dbec/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230223222841-637eb2293923/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230303212802-e74f57abe488/go.mod h1:TvhZT5f700eVlTNwND1xoEZQeWTB2RY/65kplwl/bFA= +google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230320184635-7606e756e683/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230323212658-478b75c54725/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230330154414-c0448cd141ea/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230331144136-dcfb400f0633/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230525234025-438c736192d0/go.mod h1:9ExIQyXL5hZrHzQceCwuSYwZZ5QZBazOcprJ5rgs3lY= +google.golang.org/genproto v0.0.0-20230526161137-0005af68ea54/go.mod h1:zqTuNwFlFRsw5zIts5VnzLQxSRqh+CGOTVMlYbY0Eyk= +google.golang.org/genproto v0.0.0-20240123012728-ef4313101c80 h1:KAeGQVN3M9nD0/bQXnr/ClcEMJ968gUXJQ9pwfSynuQ= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234020-1aefcd67740a/go.mod h1:ts19tUU+Z0ZShN1y3aPyq2+O3d5FUNNgT6FtOzmrNn8= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234035-dd9d682886f9/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 h1:CkkIfIt50+lT6NHAVoRYEyAvQGFM7xEwXUUywFvEb3Q= +google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576/go.mod h1:1R3kvZ1dtP3+4p4d3G8uJ8rFk/fWlScl38vanWACI08= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234015-3fc162c6f38a/go.mod h1:xURIpW9ES5+/GZhnV6beoEtxQrnkRGIfP5VQG2tCBLc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 h1:8ZmaLZE4XWrtU3MyClkYqqtl6Oegr3235h7jxsDyqCY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g= +google.golang.org/grpc v1.68.1 h1:oI5oTa11+ng8r8XMMN7jAOmWfPZWbYpCFaMUTACxkM0= +google.golang.org/grpc v1.68.1/go.mod h1:+q1XYFJjShcqn0QZHvCyeR4CXPA+llXIeUIfIe00waw= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM= +google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= +gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o= +gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g= +helm.sh/helm/v3 v3.18.5 h1:Cc3Z5vd6kDrZq9wO9KxKLNEickiTho6/H/dBNRVSos4= +helm.sh/helm/v3 v3.18.5/go.mod h1:L/dXDR2r539oPlFP1PJqKAC1CUgqHJDLkxKpDGrWnyg= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= +k8s.io/api v0.33.3 h1:SRd5t//hhkI1buzxb288fy2xvjubstenEKL9K51KBI8= +k8s.io/api v0.33.3/go.mod h1:01Y/iLUjNBM3TAvypct7DIj0M0NIZc+PzAHCIo0CYGE= +k8s.io/apiextensions-apiserver v0.33.3 h1:qmOcAHN6DjfD0v9kxL5udB27SRP6SG/MTopmge3MwEs= +k8s.io/apiextensions-apiserver v0.33.3/go.mod h1:oROuctgo27mUsyp9+Obahos6CWcMISSAPzQ77CAQGz8= +k8s.io/apimachinery v0.33.3 h1:4ZSrmNa0c/ZpZJhAgRdcsFcZOw1PQU1bALVQ0B3I5LA= +k8s.io/apimachinery v0.33.3/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM= +k8s.io/client-go v0.33.3 h1:M5AfDnKfYmVJif92ngN532gFqakcGi6RvaOF16efrpA= +k8s.io/client-go v0.33.3/go.mod h1:luqKBQggEf3shbxHY4uVENAxrDISLOarxpTKMiUuujg= +k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= +k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8= +k8s.io/kubectl v0.33.3 h1:r/phHvH1iU7gO/l7tTjQk2K01ER7/OAJi8uFHHyWSac= +k8s.io/kubectl v0.33.3/go.mod h1:euj2bG56L6kUGOE/ckZbCoudPwuj4Kud7BR0GzyNiT0= +k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 h1:M3sRQVHv7vB20Xc2ybTt7ODCeFj6JSWYFzOFnYeS6Ro= +k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.2/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.3/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc= +modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw= +modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.8/go.mod h1:zNjwkizS+fIFDrDjIAgBSCLkWbJuHF+ar3QRn+Z9aws= +modernc.org/ccgo/v3 v3.16.9/go.mod h1:zNMzC9A9xeNUepy6KuZBbugn3c0Mc9TeiJO4lgvkJDo= +modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= +modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= +modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A= +modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU= +modernc.org/libc v1.16.17/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU= +modernc.org/libc v1.16.19/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.17.0/go.mod h1:XsgLldpP4aWlPlsjqKRdHPqCxCjISdHfM/yeWC5GyW0= +modernc.org/libc v1.17.1/go.mod h1:FZ23b+8LjxZs7XtFMbSzL/EhPxNbfZbErxEHc7cbD9s= +modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.0/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.1/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/sqlite v1.18.1/go.mod h1:6ho+Gow7oX5V+OiOQ6Tr4xeqbx13UZ6t+Fw9IRUG4d4= +modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw= +modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw= +modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw= +modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8= +oras.land/oras-go v1.2.7 h1:KF9rBAtKYMGB5gjgHV5XquUfYDER3ecQBEXjdI7KZWI= +oras.land/oras-go v1.2.7/go.mod h1:WVpIPbm82xjWT/GJU3TqZ0y9Ctj3DGco4wLYvGdOVvA= +oras.land/oras-go/v2 v2.6.0 h1:X4ELRsiGkrbeox69+9tzTu492FMUu7zJQW6eJU+I2oc= +oras.land/oras-go/v2 v2.6.0/go.mod h1:magiQDfG6H1O9APp+rOsvCPcW1GD2MM7vgnKY0Y+u1o= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo= +sigs.k8s.io/kustomize/api v0.19.0 h1:F+2HB2mU1MSiR9Hp1NEgoU2q9ItNOaBJl0I4Dlus5SQ= +sigs.k8s.io/kustomize/api v0.19.0/go.mod h1:/BbwnivGVcBh1r+8m3tH1VNxJmHSk1PzP5fkP6lbL1o= +sigs.k8s.io/kustomize/kyaml v0.19.0 h1:RFge5qsO1uHhwJsu3ipV7RNolC7Uozc0jUBC/61XSlA= +sigs.k8s.io/kustomize/kyaml v0.19.0/go.mod h1:FeKD5jEOH+FbZPpqUghBP8mrLjJ3+zD3/rf9NNu1cwY= +sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU= +sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= +sigs.k8s.io/yaml v1.5.0 h1:M10b2U7aEUY6hRtU870n2VTPgR5RZiL/I6Lcc2F4NUQ= +sigs.k8s.io/yaml v1.5.0/go.mod h1:wZs27Rbxoai4C0f8/9urLZtZtF3avA3gKvGyPdDqTO4= + +GOSUM_EOF + +cd "$PREFETCH_DIR" + +# Fill the module cache with the pinned dependency graph. -modfile points at the +# inline-generated manifest so the download never touches the repository tree. +"$GO" mod download -modfile "$PREFETCH_DIR/go.mod" diff --git a/kubecfg--kubecfg.64da3e7/environment/executable b/kubecfg--kubecfg.64da3e7/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..f939ff0b8c3257ce56b56348d11042eefddd0ff6 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78332e621c5a5a4159e71a94e66c3bd6727aae6d2dec3e45d1cc35b1c30a4e33 +size 76726901 diff --git a/kubecfg--kubecfg.64da3e7/environment/harbor_prepare_download_env.sh b/kubecfg--kubecfg.64da3e7/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kubecfg--kubecfg.64da3e7/environment/programgym-go.tar.gz b/kubecfg--kubecfg.64da3e7/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubecfg--kubecfg.64da3e7/environment/workspace.tar.gz b/kubecfg--kubecfg.64da3e7/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6236041218ce3b2d84ecf8628ea5dc642d76f701 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0c4c3c9a89404241638271cd659714731810a00534009952f51f6985b25d281 +size 1610 diff --git a/kubecfg--kubecfg.64da3e7/instruction.md b/kubecfg--kubecfg.64da3e7/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kubecfg--kubecfg.64da3e7/solution/solve.sh b/kubecfg--kubecfg.64da3e7/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kubecfg--kubecfg.64da3e7/task.toml b/kubecfg--kubecfg.64da3e7/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1bad7341979c292a570948d04f77f9b5588f5757 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kubecfg--kubecfg.64da3e7" +description = "Synthetic ProgramGym cleanroom reconstruction task for kubecfg/kubecfg" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kubecfg__kubecfg.64da3e7" +repository = "kubecfg/kubecfg" +commit = "64da3e7300577d84af03919d087c7bd89f319b8a" +language = "go" +difficulty = "medium" +difficulty_score = 3.9788535853927645 +test_branches = 6 +test_count = 833 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kubecfg--kubecfg.64da3e7/tests/Dockerfile b/kubecfg--kubecfg.64da3e7/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18982f72e90272de65d43f035f12bce826cee126 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/Dockerfile @@ -0,0 +1,73 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --break-system-packages \ + --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_01.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..748c65c8e694d4414cdaed3685b1c2dda800ee80 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f56ca607b379da0e3415ec04b1d9d036f7b69db2baca52d2f17bab7b5bb9ab6f +size 21238 diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_02.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8ebab9229320ddba61e72eeb88a8fcac33fcd643 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dacd68bf2da0af12696e0b86217cae46e8e963a439b2dbbc97567c1eb4926718 +size 24840 diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_03.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..bab9fe621a01546505d8710ac40cf5fd940ed91e --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d84d8eae25fea643e3f6dfcc09e866a8bf2419fd7de9cff28e60f27d033774b +size 15815 diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_04.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9d018ae868e7c149de9b14423dc22746bd782c48 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d244774c1e3733b9ab10cb962c5003786c7b7daad28bb5e5f0243ea061e6d1dc +size 51851 diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_05.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_05.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..aadeda2a3b71deccb4f10a8432421a21b001819f --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_05.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:daaf446a1e38707944f0bf6996c25f7cae0cd1a9aa4d3bb4f73983868b614df5 +size 11314 diff --git a/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_06.tar.gz b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_06.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d519411120fe33330f3d4aab03f295ce870c932b --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/blobs/tests/generated_module_06.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e852f686fc232d5479faf05d40f6ea853e95314c21c984c6547bb20ac0368cd +size 13237 diff --git a/kubecfg--kubecfg.64da3e7/tests/download.sh b/kubecfg--kubecfg.64da3e7/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..a95b67a64f59a2f14ee125f1a3d85effca8e6501 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/download.sh @@ -0,0 +1,2179 @@ +#!/usr/bin/env bash +# ProgramGym Go download.sh for github.com/kubecfg/kubecfg (module mode). +# Standalone dependency-prefetch stage. Generates go.mod/go.sum inline, then +# runs `go mod download` so the offline `build.sh` can build ./executable with +# no network access. The module version pins match the repository's go.mod. + +set -euo pipefail + +# The pipeline runs the base-image Go toolchain. go.mod declares go 1.24.5 and +# the base toolchain is 1.25.x, so it is sufficient; use the base GOROOT. +GO=$(command -v go) + +PREFETCH_DIR="/workspace/.programgym_build_env/go-prefetch" +mkdir -p "$PREFETCH_DIR" + +# Embedded go.mod, byte-for-byte identical to the repository's go.mod. +cat > "$PREFETCH_DIR/go.mod" <<'GOMOD_EOF' +module github.com/kubecfg/kubecfg + +require ( + github.com/Masterminds/sprig/v3 v3.3.0 + github.com/containerd/containerd v1.7.30 + github.com/docker/cli v28.5.1+incompatible + github.com/evanphx/json-patch/v5 v5.9.11 + github.com/ghodss/yaml v1.0.0 + github.com/go-git/go-git/v5 v5.17.1 + github.com/golang/protobuf v1.5.4 + github.com/google/gnostic v0.7.0 + github.com/google/go-containerregistry v0.14.0 + github.com/google/go-jsonnet v0.22.0 + github.com/hexops/gotextdiff v1.0.3 + github.com/klauspost/compress v1.18.0 + github.com/kubecfg/ursonnet v0.1.1 + github.com/kubecfg/yaml/v2 v2.4.2 + github.com/mattn/go-isatty v0.0.20 + github.com/onsi/ginkgo/v2 v2.21.0 + github.com/onsi/gomega v1.35.1 + github.com/opencontainers/image-spec v1.1.1 + github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 + github.com/sirupsen/logrus v1.9.4 + github.com/spf13/cobra v1.10.1 + github.com/spf13/pflag v1.0.9 + github.com/spf13/viper v1.18.2 + github.com/stretchr/testify v1.11.1 + golang.org/x/crypto v0.45.0 + gopkg.in/yaml.v3 v3.0.1 + helm.sh/helm/v3 v3.18.5 + k8s.io/api v0.33.3 + k8s.io/apiextensions-apiserver v0.33.3 + k8s.io/apimachinery v0.33.3 + k8s.io/client-go v0.33.3 + k8s.io/klog/v2 v2.130.1 + k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff + k8s.io/kubectl v0.33.3 + oras.land/oras-go v1.2.7 + oras.land/oras-go/v2 v2.6.0 + sigs.k8s.io/kustomize/api v0.19.0 + sigs.k8s.io/kustomize/kyaml v0.19.0 +) + +require ( + dario.cat/mergo v1.0.1 // indirect + github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect + github.com/BurntSushi/toml v1.5.0 // indirect + github.com/Masterminds/goutils v1.1.1 // indirect + github.com/Masterminds/semver/v3 v3.3.0 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/ProtonMail/go-crypto v1.1.6 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cloudflare/circl v1.6.3 // indirect + github.com/containerd/errdefs v0.3.0 // indirect + github.com/containerd/log v0.1.0 // indirect + github.com/containerd/platforms v0.2.1 // indirect + github.com/cyphar/filepath-securejoin v0.5.1 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/distribution/reference v0.6.0 // indirect + github.com/docker/distribution v2.8.3+incompatible // indirect + github.com/docker/docker v28.5.1+incompatible // indirect + github.com/docker/docker-credential-helpers v0.8.2 // indirect + github.com/docker/go-connections v0.6.0 // indirect + github.com/docker/go-metrics v0.0.1 // indirect + github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect + github.com/emicklei/go-restful/v3 v3.11.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/fxamacker/cbor/v2 v2.7.0 // indirect + github.com/go-errors/errors v1.4.2 // indirect + github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect + github.com/go-git/go-billy/v5 v5.8.0 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-openapi/jsonpointer v0.21.0 // indirect + github.com/go-openapi/jsonreference v0.20.2 // indirect + github.com/go-openapi/swag v0.23.0 // indirect + github.com/go-task/slim-sprig/v3 v3.0.0 // indirect + github.com/gobwas/glob v0.2.3 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect + github.com/google/gnostic-models v0.6.9 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db // indirect + github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/mux v1.8.1 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/huandu/xstrings v1.5.0 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/kevinburke/ssh_config v1.2.0 // indirect + github.com/magiconair/properties v1.8.7 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/go-homedir v1.1.0 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/moby/locker v1.0.1 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/pelletier/go-toml/v2 v2.1.0 // indirect + github.com/pjbgf/sha1cd v0.3.2 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_golang v1.22.0 // indirect + github.com/prometheus/client_model v0.6.1 // indirect + github.com/prometheus/common v0.62.0 // indirect + github.com/prometheus/procfs v0.15.1 // indirect + github.com/sagikazarmark/locafero v0.4.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect + github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirect + github.com/shopspring/decimal v1.4.0 // indirect + github.com/skeema/knownhosts v1.3.1 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.7.0 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + github.com/x448/float16 v0.8.4 // indirect + github.com/xanzy/ssh-agent v0.3.3 // indirect + github.com/xlab/treeprint v1.2.0 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 // indirect + go.opentelemetry.io/otel v1.33.0 // indirect + go.opentelemetry.io/otel/metric v1.33.0 // indirect + go.opentelemetry.io/otel/trace v1.33.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect + go.yaml.in/yaml/v3 v3.0.3 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect + golang.org/x/net v0.47.0 // indirect + golang.org/x/oauth2 v0.30.0 // indirect + golang.org/x/sync v0.18.0 // indirect + golang.org/x/sys v0.38.0 // indirect + golang.org/x/term v0.37.0 // indirect + golang.org/x/text v0.31.0 // indirect + golang.org/x/time v0.12.0 // indirect + golang.org/x/tools v0.38.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 // indirect + google.golang.org/grpc v1.68.1 // indirect + google.golang.org/protobuf v1.36.5 // indirect + gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect + sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect + sigs.k8s.io/randfill v1.0.0 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect + sigs.k8s.io/yaml v1.5.0 // indirect +) + +go 1.24.5 + +GOMOD_EOF + +# Embedded go.sum, byte-for-byte identical to the repository's go.sum. +cat > "$PREFETCH_DIR/go.sum" <<'GOSUM_EOF' +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accessapproval v1.6.0/go.mod h1:R0EiYnwV5fsRFiKZkPHr6mwyk2wxUJ30nL4j2pcFY2E= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/accesscontextmanager v1.6.0/go.mod h1:8XCvZWfYw3K/ji0iVnp+6pu7huxoQTLmxAbVjbloTtM= +cloud.google.com/go/accesscontextmanager v1.7.0/go.mod h1:CEGLewx8dwa33aDAZQujl7Dx+uYhS0eay198wB/VumQ= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/aiplatform v1.35.0/go.mod h1:7MFT/vCaOyZT/4IIFfxH4ErVg/4ku6lKv3w0+tFTgXQ= +cloud.google.com/go/aiplatform v1.36.1/go.mod h1:WTm12vJRPARNvJ+v6P52RDHCNe4AhvjcIZ/9/RRHy/k= +cloud.google.com/go/aiplatform v1.37.0/go.mod h1:IU2Cv29Lv9oCn/9LkFiiuKfwrRTq+QQMbW+hPCxJGZw= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/analytics v0.17.0/go.mod h1:WXFa3WSym4IZ+JiKmavYdJwGG/CvpqiqczmL59bTD9M= +cloud.google.com/go/analytics v0.18.0/go.mod h1:ZkeHGQlcIPkw0R/GW+boWHhCOR43xz9RN/jn7WcqfIE= +cloud.google.com/go/analytics v0.19.0/go.mod h1:k8liqf5/HCnOUkbawNtrWWc+UAzyDlW89doe8TtoDsE= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigateway v1.5.0/go.mod h1:GpnZR3Q4rR7LVu5951qfXPJCHquZt02jf7xQx7kpqN8= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/apigeeconnect v1.5.0/go.mod h1:KFaCqvBRU6idyhSNyn3vlHXc8VMDJdRmwDF6JyFRqZ8= +cloud.google.com/go/apigeeregistry v0.4.0/go.mod h1:EUG4PGcsZvxOXAdyEghIdXwAEi/4MEaoqLMLDMIwKXY= +cloud.google.com/go/apigeeregistry v0.5.0/go.mod h1:YR5+s0BVNZfVOUkMa5pAR2xGd0A473vA5M7j247o1wM= +cloud.google.com/go/apigeeregistry v0.6.0/go.mod h1:BFNzW7yQVLZ3yj0TKcwzb8n25CFBri51GVGOEUcgQsc= +cloud.google.com/go/apikeys v0.4.0/go.mod h1:XATS/yqZbaBK0HOssf+ALHp8jAlNHUgyfprvNcBIszU= +cloud.google.com/go/apikeys v0.5.0/go.mod h1:5aQfwY4D+ewMMWScd3hm2en3hCj+BROlyrt3ytS7KLI= +cloud.google.com/go/apikeys v0.6.0/go.mod h1:kbpXu5upyiAlGkKrJgQl8A0rKNNJ7dQ377pdroRSSi8= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/appengine v1.6.0/go.mod h1:hg6i0J/BD2cKmDJbaFSYHFyZkgBEfQrDg/X0V5fJn84= +cloud.google.com/go/appengine v1.7.0/go.mod h1:eZqpbHFCqRGa2aCdope7eC0SWLV1j0neb/QnMJVWx6A= +cloud.google.com/go/appengine v1.7.1/go.mod h1:IHLToyb/3fKutRysUlFO0BPt5j7RiQ45nrzEJmKTo6E= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/area120 v0.7.0/go.mod h1:a3+8EUD1SX5RUcCs3MY5YasiO1z6yLiNLRiFrykbynY= +cloud.google.com/go/area120 v0.7.1/go.mod h1:j84i4E1RboTWjKtZVWXPqvK5VHQFJRF2c1Nm69pWm9k= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/artifactregistry v1.11.1/go.mod h1:lLYghw+Itq9SONbCa1YWBoWs1nOucMH0pwXN1rOBZFI= +cloud.google.com/go/artifactregistry v1.11.2/go.mod h1:nLZns771ZGAwVLzTX/7Al6R9ehma4WUEhZGWV6CeQNQ= +cloud.google.com/go/artifactregistry v1.12.0/go.mod h1:o6P3MIvtzTOnmvGagO9v/rOjjA0HmhJ+/6KAXrmYDCI= +cloud.google.com/go/artifactregistry v1.13.0/go.mod h1:uy/LNfoOIivepGhooAUpL1i30Hgee3Cu0l4VTWHUC08= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/asset v1.11.1/go.mod h1:fSwLhbRvC9p9CXQHJ3BgFeQNM4c9x10lqlrdEUYXlJo= +cloud.google.com/go/asset v1.12.0/go.mod h1:h9/sFOa4eDIyKmH6QMpm4eUK3pDojWnUhTgJlk762Hg= +cloud.google.com/go/asset v1.13.0/go.mod h1:WQAMyYek/b7NBpYq/K4KJWcRqzoalEsxz/t/dTk4THw= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/assuredworkloads v1.10.0/go.mod h1:kwdUQuXcedVdsIaKgKTp9t0UJkE5+PAVNhdQm4ZVq2E= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/automl v1.12.0/go.mod h1:tWDcHDp86aMIuHmyvjuKeeHEGq76lD7ZqfGLN6B0NuU= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= +cloud.google.com/go/beyondcorp v0.4.0/go.mod h1:3ApA0mbhHx6YImmuubf5pyW8srKnCEPON32/5hj+RmM= +cloud.google.com/go/beyondcorp v0.5.0/go.mod h1:uFqj9X+dSfrheVp7ssLTaRHd2EHqSL4QZmH4e8WXGGU= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= +cloud.google.com/go/bigquery v1.47.0/go.mod h1:sA9XOgy0A8vQK9+MWhEQTY6Tix87M/ZurWFIxmF9I/E= +cloud.google.com/go/bigquery v1.48.0/go.mod h1:QAwSz+ipNgfL5jxiaK7weyOhzdoAy1zFm0Nf1fysJac= +cloud.google.com/go/bigquery v1.49.0/go.mod h1:Sv8hMmTFFYBlt/ftw2uN6dFdQPzBlREY9yBh7Oy7/4Q= +cloud.google.com/go/bigquery v1.50.0/go.mod h1:YrleYEh2pSEbgTBZYMJ5SuSr0ML3ypjRB1zgf7pvQLU= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/billing v1.12.0/go.mod h1:yKrZio/eu+okO/2McZEbch17O5CB5NpZhhXG6Z766ss= +cloud.google.com/go/billing v1.13.0/go.mod h1:7kB2W9Xf98hP9Sr12KfECgfGclsH3CQR0R08tnRlRbc= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/binaryauthorization v1.5.0/go.mod h1:OSe4OU1nN/VswXKRBmciKpo9LulY41gch5c68htf3/Q= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/certificatemanager v1.6.0/go.mod h1:3Hh64rCKjRAX8dXgRAyOcY5vQ/fE1sh8o+Mdd6KPgY8= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/channel v1.11.0/go.mod h1:IdtI0uWGqhEeatSB62VOoJ8FSUhJ9/+iGkJVqp74CGE= +cloud.google.com/go/channel v1.12.0/go.mod h1:VkxCGKASi4Cq7TbXxlaBezonAYpp1GCnKMY6tnMQnLU= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/cloudbuild v1.6.0/go.mod h1:UIbc/w9QCbH12xX+ezUsgblrWv+Cv4Tw83GiSMHOn9M= +cloud.google.com/go/cloudbuild v1.7.0/go.mod h1:zb5tWh2XI6lR9zQmsm1VRA+7OCuve5d8S+zJUul8KTg= +cloud.google.com/go/cloudbuild v1.9.0/go.mod h1:qK1d7s4QlO0VwfYn5YuClDGg2hfmLZEb4wQGAbIgL1s= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/clouddms v1.5.0/go.mod h1:QSxQnhikCLUw13iAbffF2CZxAER3xDGNHjsTAkQJcQA= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/cloudtasks v1.9.0/go.mod h1:w+EyLsVkLWHcOaqNEyvcKAsWp9p29dL6uL9Nst1cI7Y= +cloud.google.com/go/cloudtasks v1.10.0/go.mod h1:NDSoTLkZ3+vExFEWu2UJV1arUyzVDAiZtdWcsUyNwBs= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute v1.18.0/go.mod h1:1X7yHxec2Ga+Ss6jPyjxRxpu2uu7PLgsOVXvgU0yacs= +cloud.google.com/go/compute v1.19.0/go.mod h1:rikpw2y+UMidAe9tISo04EHNOIf42RLYF/q8Bs93scU= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/contactcenterinsights v1.6.0/go.mod h1:IIDlT6CLcDoyv79kDv8iWxMSTZhLxSCofVV5W6YFM/w= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/container v1.13.1/go.mod h1:6wgbMPeQRw9rSnKBCAJXnds3Pzj03C4JHamr8asWKy4= +cloud.google.com/go/container v1.14.0/go.mod h1:3AoJMPhHfLDxLvrlVWaK57IXzaPnLaZq63WX59aQBfM= +cloud.google.com/go/container v1.15.0/go.mod h1:ft+9S0WGjAyjDggg5S06DXj+fHJICWg8L7isCQe9pQA= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/containeranalysis v0.7.0/go.mod h1:9aUL+/vZ55P2CXfuZjS4UjQ9AgXoSw8Ts6lemfmxBxI= +cloud.google.com/go/containeranalysis v0.9.0/go.mod h1:orbOANbwk5Ejoom+s+DUCTTJ7IBdBQJDcSylAx/on9s= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/datacatalog v1.8.1/go.mod h1:RJ58z4rMp3gvETA465Vg+ag8BGgBdnRPEMMSTr5Uv+M= +cloud.google.com/go/datacatalog v1.12.0/go.mod h1:CWae8rFkfp6LzLumKOnmVh4+Zle4A3NXLzVJ1d1mRm0= +cloud.google.com/go/datacatalog v1.13.0/go.mod h1:E4Rj9a5ZtAxcQJlEBTLgMTphfP11/lNaAshpoBgemX8= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataflow v0.8.0/go.mod h1:Rcf5YgTKPtQyYz8bLYhFoIV/vP39eL7fWNcSOyFfLJE= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/dataform v0.6.0/go.mod h1:QPflImQy33e29VuapFdf19oPbE4aYTJxr31OAPV+ulA= +cloud.google.com/go/dataform v0.7.0/go.mod h1:7NulqnVozfHvWUBpMDfKMUESr+85aJsC/2O0o3jWPDE= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datafusion v1.6.0/go.mod h1:WBsMF8F1RhSXvVM8rCV3AeyWVxcC2xY6vith3iw3S+8= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/datalabeling v0.7.0/go.mod h1:WPQb1y08RJbmpM3ww0CSUAGweL0SxByuW2E+FU+wXcM= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataplex v1.5.2/go.mod h1:cVMgQHsmfRoI5KFYq4JtIBEUbYwc3c7tXmIDhRmNNVQ= +cloud.google.com/go/dataplex v1.6.0/go.mod h1:bMsomC/aEJOSpHXdFKFGQ1b0TDPIeL28nJObeO1ppRs= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= +cloud.google.com/go/dataqna v0.7.0/go.mod h1:Lx9OcIIeqCrw1a6KdO3/5KMP1wAmTc0slZWwP12Qq3c= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastore v1.11.0/go.mod h1:TvGxBIHCS50u8jzG+AW/ppf87v1of8nwzFNgEZU1D3c= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/datastream v1.6.0/go.mod h1:6LQSuswqLa7S4rPAOZFVjHIG3wJIjZcZrw8JDEDJuIs= +cloud.google.com/go/datastream v1.7.0/go.mod h1:uxVRMm2elUSPuh65IbZpzJNMbuzkcvu5CjMqVIUHrww= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/deploy v1.6.0/go.mod h1:f9PTHehG/DjCom3QH0cntOVRm93uGBDt2vKzAPwpXQI= +cloud.google.com/go/deploy v1.8.0/go.mod h1:z3myEJnA/2wnB4sgjqdMfgxCA0EqC3RBTNcVPs93mtQ= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dialogflow v1.29.0/go.mod h1:b+2bzMe+k1s9V+F2jbJwpHPzrnIyHihAdRFMtn2WXuM= +cloud.google.com/go/dialogflow v1.31.0/go.mod h1:cuoUccuL1Z+HADhyIA7dci3N5zUssgpBJmCzI6fNRB4= +cloud.google.com/go/dialogflow v1.32.0/go.mod h1:jG9TRJl8CKrDhMEcvfcfFkkpp8ZhgPz3sBGmAUYJ2qE= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/dlp v1.9.0/go.mod h1:qdgmqgTyReTz5/YNSSuueR8pl7hO0o9bQ39ZhtgkWp4= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/documentai v1.16.0/go.mod h1:o0o0DLTEZ+YnJZ+J4wNfTxmDVyrkzFvttBXXtYRMHkM= +cloud.google.com/go/documentai v1.18.0/go.mod h1:F6CK6iUH8J81FehpskRmhLq/3VlwQvb7TvwOceQ2tbs= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/domains v0.8.0/go.mod h1:M9i3MMDzGFXsydri9/vW+EWz9sWb4I6WyHqdlAk0idE= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/edgecontainer v0.3.0/go.mod h1:FLDpP4nykgwwIfcLt6zInhprzw0lEi2P1fjO6Ie0qbc= +cloud.google.com/go/edgecontainer v1.0.0/go.mod h1:cttArqZpBB2q58W/upSG++ooo6EsblxDIolxa3jSjbY= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/essentialcontacts v1.5.0/go.mod h1:ay29Z4zODTuwliK7SnX8E86aUF2CTzdNtvv42niCX0M= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/eventarc v1.10.0/go.mod h1:u3R35tmZ9HvswGRBnF48IlYgYeBcPUCjkr4BTdem2Kw= +cloud.google.com/go/eventarc v1.11.0/go.mod h1:PyUjsUKPWoRBCHeOxZd/lbOOjahV41icXyUY5kSTvVY= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= +cloud.google.com/go/filestore v1.5.0/go.mod h1:FqBXDWBp4YLHqRnVGveOkHDf8svj9r5+mUDLupOWEDs= +cloud.google.com/go/filestore v1.6.0/go.mod h1:di5unNuss/qfZTw2U9nhFqo8/ZDSc466dre85Kydllg= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/functions v1.10.0/go.mod h1:0D3hEOe3DbEvCXtYOZHQZmD+SzYsi1YbI7dGvHfldXw= +cloud.google.com/go/functions v1.12.0/go.mod h1:AXWGrF3e2C/5ehvwYo/GH6O5s09tOPksiKhz+hH8WkA= +cloud.google.com/go/functions v1.13.0/go.mod h1:EU4O007sQm6Ef/PwRsI8N2umygGqPBS/IZQKBQBcJ3c= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gaming v1.9.0/go.mod h1:Fc7kEmCObylSWLO334NcO+O9QMDyz+TKC4v1D7X+Bc0= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkeconnect v0.7.0/go.mod h1:SNfmVqPkaEi3bF/B3CNZOAYPYdg7sU+obZ+QTky2Myw= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkehub v0.11.0/go.mod h1:JOWHlmN+GHyIbuWQPl47/C2RFhnFKH38jH9Ascu3n0E= +cloud.google.com/go/gkehub v0.12.0/go.mod h1:djiIwwzTTBrF5NaXCGv3mf7klpEMcST17VBTVVDcuaw= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/gkemulticloud v0.5.0/go.mod h1:W0JDkiyi3Tqh0TJr//y19wyb1yf8llHVto2Htf2Ja3Y= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/gsuiteaddons v1.5.0/go.mod h1:TFCClYLd64Eaa12sFVmUyG62tk4mdIsI7pAnSXRkcFo= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iam v0.11.0/go.mod h1:9PiLDanza5D+oWFZiH1uG+RnRCfEGKoyl6yo4cgWZGY= +cloud.google.com/go/iam v0.12.0/go.mod h1:knyHGviacl11zrtZUoDuYpDgLjvr28sLQaG0YB2GYAY= +cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/iap v1.6.0/go.mod h1:NSuvI9C/j7UdjGjIde7t7HBz+QTwBcapPE07+sSRcLk= +cloud.google.com/go/iap v1.7.0/go.mod h1:beqQx56T9O1G1yNPph+spKpNibDlYIiIixiqsQXxLIo= +cloud.google.com/go/iap v1.7.1/go.mod h1:WapEwPc7ZxGt2jFGB/C/bm+hP0Y6NXzOYGjpPnmMS74= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/ids v1.3.0/go.mod h1:JBdTYwANikFKaDP6LtW5JAi4gubs57SVNQjemdt6xV4= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/iot v1.5.0/go.mod h1:mpz5259PDl3XJthEmh9+ap0affn/MqNSP4My77Qql9o= +cloud.google.com/go/iot v1.6.0/go.mod h1:IqdAsmE2cTYYNO1Fvjfzo9po179rAtJeVGUvkLN3rLE= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/kms v1.8.0/go.mod h1:4xFEhYFqvW+4VMELtZyxomGSYtSQKzM178ylFW4jMAg= +cloud.google.com/go/kms v1.9.0/go.mod h1:qb1tPTgfF9RQP8e1wq4cLFErVuTJv7UsSC915J8dh3w= +cloud.google.com/go/kms v1.10.0/go.mod h1:ng3KTUtQQU9bPX3+QGLsflZIHlkbn8amFAMY63m8d24= +cloud.google.com/go/kms v1.10.1/go.mod h1:rIWk/TryCkR59GMC3YtHtXeLzd634lBbKenvyySAyYI= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/language v1.9.0/go.mod h1:Ns15WooPM5Ad/5no/0n81yUetis74g3zrbeJBE+ptUY= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/maps v0.6.0/go.mod h1:o6DAMMfb+aINHz/p/jbcY+mYeXBoZoxTfdSQ8VAJaCw= +cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/mediatranslation v0.7.0/go.mod h1:LCnB/gZr90ONOIQLgSXagp8XUW1ODs2UmUMvcgMfI2I= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/memcache v1.9.0/go.mod h1:8oEyzXCu+zo9RzlEaEjHl4KkgjlNDaXbCQeQWlzNFJM= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/metastore v1.10.0/go.mod h1:fPEnH3g4JJAk+gMRnrAnoqyv2lpUCqJPWOodSaf45Eo= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/monitoring v1.12.0/go.mod h1:yx8Jj2fZNEkL/GYZyTLS4ZtZEZN8WtDEiEqG4kLK50w= +cloud.google.com/go/monitoring v1.13.0/go.mod h1:k2yMBAB1H9JT/QETjNkgdCGD9bPF712XiLTVr+cBrpw= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkconnectivity v1.10.0/go.mod h1:UP4O4sWXJG13AqrTdQCD9TnLGEbtNRqjuaaA7bNjF5E= +cloud.google.com/go/networkconnectivity v1.11.0/go.mod h1:iWmDD4QF16VCDLXUqvyspJjIEtBR/4zq5hwnY2X3scM= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networkmanagement v1.6.0/go.mod h1:5pKPqyXjB/sgtvB5xqOemumoQNB7y95Q7S+4rjSOPYY= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/networksecurity v0.7.0/go.mod h1:mAnzoxx/8TBSyXEeESMy9OOYwo1v+gZ5eMRnsT5bC8k= +cloud.google.com/go/networksecurity v0.8.0/go.mod h1:B78DkqsxFG5zRSVuwYFRZ9Xz8IcQ5iECsNrPn74hKHU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/notebooks v1.7.0/go.mod h1:PVlaDGfJgj1fl1S3dUwhFMXFgfYGhYQt2164xOMONmE= +cloud.google.com/go/notebooks v1.8.0/go.mod h1:Lq6dYKOYOWUCTvw5t2q1gp1lAp0zxAxRycayS0iJcqQ= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/optimization v1.3.1/go.mod h1:IvUSefKiwd1a5p0RgHDbWCIbDFgKuEdB+fPPuP0IDLI= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orchestration v1.6.0/go.mod h1:M62Bevp7pkxStDfFfTuCOaXgaaqRAga1yKyoMtEoWPQ= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/orgpolicy v1.10.0/go.mod h1:w1fo8b7rRqlXlIJbVhOMPrwVljyuW5mqssvBtU18ONc= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/osconfig v1.11.0/go.mod h1:aDICxrur2ogRd9zY5ytBLV89KEgT2MKB2L/n6x1ooPw= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/oslogin v1.9.0/go.mod h1:HNavntnH8nzrn8JCTT5fj18FuJLFJc4NaZJtBnQtKFs= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/phishingprotection v0.7.0/go.mod h1:8qJI4QKHoda/sb/7/YmMQ2omRLSLYSu9bU0EKCNI+Lk= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/policytroubleshooter v1.5.0/go.mod h1:Rz1WfV+1oIpPdN2VvvuboLVRsB1Hclg3CKQ53j9l8vw= +cloud.google.com/go/policytroubleshooter v1.6.0/go.mod h1:zYqaPTsmfvpjm5ULxAyD/lINQxJ0DDsnWOP/GZ7xzBc= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= +cloud.google.com/go/privatecatalog v0.7.0/go.mod h1:2s5ssIFO69F5csTXcwBP7NPFTZvps26xGzvQ2PQaBYg= +cloud.google.com/go/privatecatalog v0.8.0/go.mod h1:nQ6pfaegeDAq/Q5lrfCQzQLhubPiZhSaNhIgfJlnIXs= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsub v1.28.0/go.mod h1:vuXFpwaVoIPQMGXqRyUQigu/AX1S3IWugR9xznmcXX8= +cloud.google.com/go/pubsub v1.30.0/go.mod h1:qWi1OPS0B+b5L+Sg6Gmc9zD1Y+HaM0MdUr7LsupY1P4= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/pubsublite v1.6.0/go.mod h1:1eFCS0U11xlOuMFV/0iBqw3zP12kddMeCbj/F3FSj9k= +cloud.google.com/go/pubsublite v1.7.0/go.mod h1:8hVMwRXfDfvGm3fahVbtDbiLePT3gpoiJYJY+vxWxVM= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recaptchaenterprise/v2 v2.6.0/go.mod h1:RPauz9jeLtB3JVzg6nCbe12qNoaa8pXc4d/YukAmcnA= +cloud.google.com/go/recaptchaenterprise/v2 v2.7.0/go.mod h1:19wVj/fs5RtYtynAPJdDTb69oW0vNHYDBTbB4NvMD9c= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommendationengine v0.7.0/go.mod h1:1reUcE3GIu6MeBz/h5xZJqNLuuVjNg1lmWMPyjatzac= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/recommender v1.9.0/go.mod h1:PnSsnZY7q+VL1uax2JWkt/UegHssxjUVVCrX52CuEmQ= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/redis v1.11.0/go.mod h1:/X6eicana+BWcUda5PpwZC48o37SiFVTFSs0fWAJ7uQ= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcemanager v1.5.0/go.mod h1:eQoXNAiAvCf5PXxWxXjhKQoTMaUSNrEfg+6qdf/wots= +cloud.google.com/go/resourcemanager v1.6.0/go.mod h1:YcpXGRs8fDzcUl1Xw8uOVmI8JEadvhRIkoXXUNVYcVo= +cloud.google.com/go/resourcemanager v1.7.0/go.mod h1:HlD3m6+bwhzj9XCouqmeiGuni95NTrExfhoSrkC/3EI= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/resourcesettings v1.5.0/go.mod h1:+xJF7QSG6undsQDfsCJyqWXyBwUoJLhetkRMDRnIoXA= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/retail v1.12.0/go.mod h1:UMkelN/0Z8XvKymXFbD4EhFJlYKRx1FGhQkVPU5kF14= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/run v0.8.0/go.mod h1:VniEnuBwqjigv0A7ONfQUaEItaiCRVujlMqerPPiktM= +cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/scheduler v1.8.0/go.mod h1:TCET+Y5Gp1YgHT8py4nlg2Sew8nUHMqcpousDgXJVQc= +cloud.google.com/go/scheduler v1.9.0/go.mod h1:yexg5t+KSmqu+njTIh3b7oYPheFtBWGcbVUYF1GGMIc= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/secretmanager v1.10.0/go.mod h1:MfnrdvKMPNra9aZtQFvBcvRU54hbPD8/HayQdlUgJpU= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/security v1.12.0/go.mod h1:rV6EhrpbNHrrxqlvW0BWAIawFWq3X90SduMJdFwtLB8= +cloud.google.com/go/security v1.13.0/go.mod h1:Q1Nvxl1PAgmeW0y3HTt54JYIvUdtcpYKVfIB8AOMZ+0= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/securitycenter v1.18.1/go.mod h1:0/25gAzCM/9OL9vVx4ChPeM/+DlfGQJDwBy/UC8AKK0= +cloud.google.com/go/securitycenter v1.19.0/go.mod h1:LVLmSg8ZkkyaNy4u7HCIshAngSQ8EcIRREP3xBnyfag= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicecontrol v1.10.0/go.mod h1:pQvyvSRh7YzUF2efw7H87V92mxU8FnFDawMClGCNuAA= +cloud.google.com/go/servicecontrol v1.11.0/go.mod h1:kFmTzYzTUIuZs0ycVqRHNaNhgR+UMUpw9n02l/pY+mc= +cloud.google.com/go/servicecontrol v1.11.1/go.mod h1:aSnNNlwEFBY+PWGQ2DoM0JJ/QUXqV5/ZD9DOLB7SnUk= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicedirectory v1.8.0/go.mod h1:srXodfhY1GFIPvltunswqXpVxFPpZjf8nkKQT7XcXaY= +cloud.google.com/go/servicedirectory v1.9.0/go.mod h1:29je5JjiygNYlmsGz8k6o+OZ8vd4f//bQLtvzkPPT/s= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/servicemanagement v1.6.0/go.mod h1:aWns7EeeCOtGEX4OvZUWCCJONRZeFKiptqKf1D0l/Jc= +cloud.google.com/go/servicemanagement v1.8.0/go.mod h1:MSS2TDlIEQD/fzsSGfCdJItQveu9NXnUniTrq/L8LK4= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/serviceusage v1.5.0/go.mod h1:w8U1JvqUqwJNPEOTQjrMHkw3IaIFLoLsPLvsE3xueec= +cloud.google.com/go/serviceusage v1.6.0/go.mod h1:R5wwQcbOWsyuOfbP9tGdAnCAc6B9DRwPG1xtWMDeuPA= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/shell v1.6.0/go.mod h1:oHO8QACS90luWgxP3N9iZVuEiSF84zNyLytb+qE2f9A= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/spanner v1.44.0/go.mod h1:G8XIgYdOK+Fbcpbs7p2fiprDw4CaZX63whnSMLVBxjk= +cloud.google.com/go/spanner v1.45.0/go.mod h1:FIws5LowYz8YAE1J8fOS7DJup8ff7xJeetWEo5REA2M= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= +cloud.google.com/go/speech v1.14.1/go.mod h1:gEosVRPJ9waG7zqqnsHpYTOoAS4KouMRLDFMekpJ0J0= +cloud.google.com/go/speech v1.15.0/go.mod h1:y6oH7GhqCaZANH7+Oe0BhgIogsNInLlz542tg3VqeYI= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= +cloud.google.com/go/storage v1.29.0/go.mod h1:4puEjyTKnku6gfKoTfNOU/W+a9JyuVNxjpS5GBrB8h4= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/storagetransfer v1.7.0/go.mod h1:8Giuj1QNb1kfLAiWM1bN6dHzfdlDAVC9rv9abHot2W4= +cloud.google.com/go/storagetransfer v1.8.0/go.mod h1:JpegsHHU1eXg7lMHkvf+KE5XDJ7EQu0GwNJbbVGanEw= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/talent v1.5.0/go.mod h1:G+ODMj9bsasAEJkQSzO2uHQWXHHXUomArjWQQYkqK6c= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/texttospeech v1.6.0/go.mod h1:YmwmFT8pj1aBblQOI3TfKmwibnsfvhIBzPXcW4EBovc= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/tpu v1.5.0/go.mod h1:8zVo1rYDFuW2l4yZVY0R0fb/v44xLh3llq7RuV61fPM= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/trace v1.8.0/go.mod h1:zH7vcsbAhklH8hWFig58HvxcxyQbaIqMarMg9hn5ECA= +cloud.google.com/go/trace v1.9.0/go.mod h1:lOQqpE5IaWY0Ixg7/r2SjixMuc6lfTFeO4QGM4dQWOk= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/translate v1.5.0/go.mod h1:29YDSYveqqpA1CQFD7NQuP49xymq17RXNaUDdc0mNu0= +cloud.google.com/go/translate v1.6.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/translate v1.7.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/video v1.12.0/go.mod h1:MLQew95eTuaNDEGriQdcYn0dTwf9oWiA4uYebxM5kdg= +cloud.google.com/go/video v1.13.0/go.mod h1:ulzkYlYgCp15N2AokzKjy7MQ9ejuynOJdf1tR5lGthk= +cloud.google.com/go/video v1.14.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/video v1.15.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/videointelligence v1.10.0/go.mod h1:LHZngX1liVtUhZvi2uNS0VQuOzNi2TkY1OakiuoUOjU= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vision/v2 v2.6.0/go.mod h1:158Hes0MvOS9Z/bDMSFpjwsUrZ5fPrdwuyyvKSGAGMY= +cloud.google.com/go/vision/v2 v2.7.0/go.mod h1:H89VysHy21avemp6xcf9b9JvZHVehWbET0uT/bcuY/0= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmmigration v1.5.0/go.mod h1:E4YQ8q7/4W9gobHjQg4JJSgXXSgY21nA5r8swQV+Xxc= +cloud.google.com/go/vmmigration v1.6.0/go.mod h1:bopQ/g4z+8qXzichC7GW1w2MjbErL54rk3/C843CjfY= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vmwareengine v0.2.2/go.mod h1:sKdctNJxb3KLZkE/6Oui94iw/xs9PRNC2wnNLXsHvH8= +cloud.google.com/go/vmwareengine v0.3.0/go.mod h1:wvoyMvNWdIzxMYSpH/R7y2h5h3WFkx6d+1TIsP39WGY= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/vpcaccess v1.6.0/go.mod h1:wX2ILaNhe7TlVa4vC5xce1bCnqE3AeH27RV31lnmZes= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/webrisk v1.8.0/go.mod h1:oJPDuamzHXgUc+b8SiHRcVInZQuybnvEW72PqTc7sSg= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/websecurityscanner v1.5.0/go.mod h1:Y6xdCPy81yi0SQnDY1xdNTNpfY1oAgXUlcfN3B3eSng= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= +cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcPALq2CxzdePw= +dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s= +dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +gioui.org v0.0.0-20210308172011-57750fc8a0a6/go.mod h1:RSH6KIUZ0p2xy5zHDxgAM4zumjgTw83q2ge/PI+yyw8= +git.sr.ht/~sbinet/gg v0.3.1/go.mod h1:KGYtlADtqsqANL9ueOFkWymvzUvLMQllU5Ixo+8v3pc= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg= +github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= +github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI= +github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= +github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0= +github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= +github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs= +github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0= +github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/Microsoft/hcsshim v0.11.7 h1:vl/nj3Bar/CvJSYo7gIQPyRWc9f3c6IeSNavBTSZNZQ= +github.com/Microsoft/hcsshim v0.11.7/go.mod h1:MV8xMfmECjl5HdO7U/3/hFVnkmSBjAjmA09d4bExKcU= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw= +github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/ajstarks/deck v0.0.0-20200831202436-30c9fc6549a9/go.mod h1:JynElWSGnm/4RlzPXRlREEwqTHAN3T56Bv2ITsFT3gY= +github.com/ajstarks/deck/generate v0.0.0-20210309230005-c3f852c02e19/go.mod h1:T13YZdzov6OU0A1+RfKZiZN9ca6VeKdBdyDV+BY97Tk= +github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= +github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apache/arrow/go/v10 v10.0.1/go.mod h1:YvhnlEePVnBS4+0z3fhPfUy7W1Ikj0Ih0vcRo/gZ1M0= +github.com/apache/arrow/go/v11 v11.0.0/go.mod h1:Eg5OsL5H+e299f7u5ssuXsuHQVEGC4xei5aX110hRiI= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= +github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/boombuler/barcode v1.0.1/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/bshuster-repo/logrus-logstash-hook v1.0.0 h1:e+C0SB5R1pu//O4MQ3f9cFuPGoOVeF2fE4Og9otCc70= +github.com/bshuster-repo/logrus-logstash-hook v1.0.0/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk= +github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= +github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM= +github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw= +github.com/containerd/containerd v1.7.30 h1:/2vezDpLDVGGmkUXmlNPLCCNKHJ5BbC5tJB5JNzQhqE= +github.com/containerd/containerd v1.7.30/go.mod h1:fek494vwJClULlTpExsmOyKCMUAbuVjlFsJQc4/j44M= +github.com/containerd/continuity v0.4.4 h1:/fNVfTJ7wIl/YPMHjf+5H32uFhl63JucB34PlCpMKII= +github.com/containerd/continuity v0.4.4/go.mod h1:/lNJvtJKUQStBzpVQ1+rasXO1LAWtUQssk28EZvJ3nE= +github.com/containerd/errdefs v0.3.0 h1:FSZgGOeK4yuT/+DnF07/Olde/q4KBoMsaamhXxIMDp4= +github.com/containerd/errdefs v0.3.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A= +github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw= +github.com/containerd/stargz-snapshotter/estargz v0.14.3 h1:OqlDCK3ZVUO6C3B/5FSkDwbkEETK84kQgEeFwDC+62k= +github.com/containerd/stargz-snapshotter/estargz v0.14.3/go.mod h1:KY//uOCIkSuNAHhJogcZtrNHdKrA99/FCCRjE3HD36o= +github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/cyphar/filepath-securejoin v0.5.1 h1:eYgfMq5yryL4fbWfkLpFFy2ukSELzaJOTaUTuh+oF48= +github.com/cyphar/filepath-securejoin v0.5.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/distribution/distribution/v3 v3.0.0 h1:q4R8wemdRQDClzoNNStftB2ZAfqOiN6UX90KJc4HjyM= +github.com/distribution/distribution/v3 v3.0.0/go.mod h1:tRNuFoZsUdyRVegq8xGNeds4KLjwLCRin/tTo6i1DhU= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI= +github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/docker/cli v28.5.1+incompatible h1:ESutzBALAD6qyCLqbQSEf1a/U8Ybms5agw59yGVc+yY= +github.com/docker/cli v28.5.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk= +github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= +github.com/docker/docker v28.5.1+incompatible h1:Bm8DchhSD2J6PsFzxC35TZo4TLGR2PdW/E69rU45NhM= +github.com/docker/docker v28.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/docker-credential-helpers v0.8.2 h1:bX3YxiGzFP5sOXWc3bTPEXdEaZSeVMrFgOr3T+zrFAo= +github.com/docker/docker-credential-helpers v0.8.2/go.mod h1:P3ci7E3lwkZg6XiHdRKft1KckHiO9a2rNtyFbZ/ry9M= +github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94= +github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE= +github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c h1:+pKlWGMw7gf6bQ+oDZB4KHQFypsfjYlq/C4rfL7D3g8= +github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA= +github.com/docker/go-metrics v0.0.1 h1:AgB/0SvBxihN0X8OR4SjsblXkbMvalQ8cjmtKQ2rQV8= +github.com/docker/go-metrics v0.0.1/go.mod h1:cG1hvH2utMXtqgqqYE9plW6lDxS3/5ayHzueweSI3Vw= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE= +github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= +github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= +github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g= +github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= +github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= +github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU= +github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/flowstack/go-jsonschema v0.1.1/go.mod h1:yL7fNggx1o8rm9RlgXv7hTBWxdBM0rVwpMwimd3F3N0= +github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E= +github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-fonts/dejavu v0.1.0/go.mod h1:4Wt4I4OU2Nq9asgDCteaAaWZOV24E+0/Pwo0gppep4g= +github.com/go-fonts/latin-modern v0.2.0/go.mod h1:rQVLdDMK+mK1xscDwsqM5J8U2jrRa3T0ecnM9pNujks= +github.com/go-fonts/liberation v0.1.1/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/liberation v0.2.0/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/stix v0.1.0/go.mod h1:w/c1f0ldAUlJmLBvlbkvVXLAD+tAMqobIIQpmnUIzUY= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= +github.com/go-git/go-billy/v5 v5.8.0 h1:I8hjc3LbBlXTtVuFNJuwYuMiHvQJDq1AT6u4DwDzZG0= +github.com/go-git/go-billy/v5 v5.8.0/go.mod h1:RpvI/rw4Vr5QA+Z60c6d6LXH0rYJo0uD5SqfmrrheCY= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= +github.com/go-git/go-git/v5 v5.17.1 h1:WnljyxIzSj9BRRUlnmAU35ohDsjRK0EKmL0evDqi5Jk= +github.com/go-git/go-git/v5 v5.17.1/go.mod h1:pW/VmeqkanRFqR6AljLcs7EA7FbZaN5MQqO7oZADXpo= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-latex/latex v0.0.0-20210118124228-b3d85cf34e07/go.mod h1:CO1AlKB2CSIqUrmQPqA0gdRIlnLEY0gK5JGjh37zN5U= +github.com/go-latex/latex v0.0.0-20210823091927-c0d11ff05a81/go.mod h1:SX0U8uGpxhq9o2S/CELCSUxEWWAuoCUcVCQWv7G2OCk= +github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs= +github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= +github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= +github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE= +github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k= +github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= +github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= +github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= +github.com/go-pdf/fpdf v0.5.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-pdf/fpdf v0.6.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= +github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= +github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/gnostic v0.7.0 h1:d7EpuFp8vVdML+y0JJJYiKeOLjKTdH/GvVkLOBWqJpw= +github.com/google/gnostic v0.7.0/go.mod h1:IAcUyMl6vtC95f60EZ8oXyqTsOersP6HbwjeG7EyDPM= +github.com/google/gnostic-models v0.6.9-0.20230804172637-c7be7c783f49/go.mod h1:BkkQ4L1KS1xMt2aWSPStnn55ChGC0DPOn2FQYj+f25M= +github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw= +github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-containerregistry v0.14.0 h1:z58vMqHxuwvAsVwvKEkmVBz2TlgBgH5k6koEXBtlYkw= +github.com/google/go-containerregistry v0.14.0/go.mod h1:aiJ2fp/SXvkWgmYHioXnbMdlgB8eXiiYOY55gfN91Wk= +github.com/google/go-jsonnet v0.22.0 h1:o0bOAIE+9SIfRZ7FXQPuta0mHLLE0AwbY/L5GTH5CH8= +github.com/google/go-jsonnet v0.22.0/go.mod h1:pLhKpu0/ODjL2Zev4y+CmCoHKAgONT1gSLQyriuYh9w= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= +github.com/googleapis/enterprise-certificate-proxy v0.2.1/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE= +github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0 h1:TmHmbvxPmaegwhDubVz0lICL0J5Ka2vwTzhoePEXsGE= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0/go.mod h1:qztMSjm835F2bXf+5HKAPIS5qsmQDqZna/PgVt4rWtI= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru/arc/v2 v2.0.5 h1:l2zaLDubNhW4XO3LnliVj0GXO3+/CGNJAg1dcN2Fpfw= +github.com/hashicorp/golang-lru/arc/v2 v2.0.5/go.mod h1:ny6zBSQZi2JxIeYcv7kt2sH2PXJtirBN7RDhRpxPkxU= +github.com/hashicorp/golang-lru/v2 v2.0.5 h1:wW7h1TG88eUIJ2i69gaE3uNVtEPIagzhGvHgwfx2Vm4= +github.com/hashicorp/golang-lru/v2 v2.0.5/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= +github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI= +github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= +github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= +github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= +github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kubecfg/ursonnet v0.1.1 h1:D8IsJFGryLCYDYx+v/qMOCsOrH9NCLUYiuilppkisH8= +github.com/kubecfg/ursonnet v0.1.1/go.mod h1:3tCiatkU+90PIexhvZDG00ISgIB7U9fM0oPAqn/jamg= +github.com/kubecfg/yaml/v2 v2.4.2 h1:eyCOIzzAX1FEf9lcDOsIvUX+oBVm9bHlg9vVHhBCEVY= +github.com/kubecfg/yaml/v2 v2.4.2/go.mod h1:z1eemV0tke+0kjM/5OLgul7hO2/YXxbWV5UFNWYKfvI= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/moby/locker v1.0.1 h1:fOXqR41zeveg4fFODix+1Ch4mj/gT0NE1XJbp/epuBg= +github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc= +github.com/moby/sys/mountinfo v0.6.2 h1:BzJjoreD5BMFNmD9Rus6gdd1pLuecOFPt8wC+Vygl78= +github.com/moby/sys/mountinfo v0.6.2/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI= +github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= +github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/onsi/ginkgo/v2 v2.21.0 h1:7rg/4f3rB88pb5obDgNZrNHrQ4e6WpjonchcpuBRnZM= +github.com/onsi/ginkgo/v2 v2.21.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo= +github.com/onsi/gomega v1.35.1 h1:Cwbd75ZBPxFSuZ6T+rN/WCb/gOc6YgFBXLlZLhC7Ds4= +github.com/onsi/gomega v1.35.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= +github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5 h1:Ii+DKncOVM8Cu1Hc+ETb5K+23HdAMvESYE3ZJ5b5cMI= +github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5/go.mod h1:iIss55rKnNBTvrwdmkUpLnDpZoAHvWaiq5+iMmen4AE= +github.com/phpdave11/gofpdf v1.4.2/go.mod h1:zpO6xFn9yxo3YLyMvW8HcKWVdbNqgIfOOp2dXMnm1mY= +github.com/phpdave11/gofpdi v1.0.12/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/phpdave11/gofpdi v1.0.13/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4= +github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g= +github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q= +github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc= +github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io= +github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I= +github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5 h1:EaDatTxkdHG+U3Bk4EUr+DZ7fOGwTfezUiUJMaIcaho= +github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5/go.mod h1:fyalQWdtzDBECAQFBJuQe5bzQ02jGd5Qcbgb97Flm7U= +github.com/redis/go-redis/extra/redisotel/v9 v9.0.5 h1:EfpWLLCyXw8PSM2/XNJLjI3Pb27yVE+gIAfeqp8LUCc= +github.com/redis/go-redis/extra/redisotel/v9 v9.0.5/go.mod h1:WZjPDy7VNzn77AAfnAfVjZNvfJTYfPetfZk5yoSTLaQ= +github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM= +github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= +github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w= +github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZKsJ8yyVxGRWYNEm9oFB8ieLgKFnamEyDmSA0BRk= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY= +github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ= +github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= +github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= +github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8= +github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w= +github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s= +github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0= +github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY= +github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ= +github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk= +github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/vbatts/tar-split v0.11.2 h1:Via6XqJr0hceW4wff3QRzD5gAk/tatMw/4ZA7cTlIME= +github.com/vbatts/tar-split v0.11.2/go.mod h1:vV3ZuO2yWSVsz+pfFzDG/upWH1JhjOiEaWq6kXyQ3VI= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= +github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ= +github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/contrib/bridges/prometheus v0.57.0 h1:UW0+QyeyBVhn+COBec3nGhfnFe5lwB0ic1JBVjzhk0w= +go.opentelemetry.io/contrib/bridges/prometheus v0.57.0/go.mod h1:ppciCHRLsyCio54qbzQv0E4Jyth/fLWDTJYfvWpcSVk= +go.opentelemetry.io/contrib/exporters/autoexport v0.57.0 h1:jmTVJ86dP60C01K3slFQa2NQ/Aoi7zA+wy7vMOKD9H4= +go.opentelemetry.io/contrib/exporters/autoexport v0.57.0/go.mod h1:EJBheUMttD/lABFyLXhce47Wr6DPWYReCzaZiXadH7g= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 h1:yd02MEjBdJkG3uabWP9apV+OuWRIXGDuJEUJbOHmCFU= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0/go.mod h1:umTcuxiv1n/s/S6/c2AT/g2CQ7u5C59sHDNmfSwgz7Q= +go.opentelemetry.io/otel v1.33.0 h1:/FerN9bax5LoK51X/sI0SVYrjSE0/yUL7DpxW4K3FWw= +go.opentelemetry.io/otel v1.33.0/go.mod h1:SUUkR6csvUQl+yjReHu5uM3EtVV7MBm5FHKRlNx4I8I= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.8.0 h1:WzNab7hOOLzdDF/EoWCt4glhrbMPVMOO5JYTmpz36Ls= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.8.0/go.mod h1:hKvJwTzJdp90Vh7p6q/9PAOd55dI6WA6sWj62a/JvSs= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.8.0 h1:S+LdBGiQXtJdowoJoQPEtI52syEP/JYBUpjO49EQhV8= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.8.0/go.mod h1:5KXybFvPGds3QinJWQT7pmXf+TN5YIa7CNYObWRkj50= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.32.0 h1:j7ZSD+5yn+lo3sGV69nW04rRR0jhYnBwjuX3r0HvnK0= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.32.0/go.mod h1:WXbYJTUaZXAbYd8lbgGuvih0yuCfOFC5RJoYnoLcGz8= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.32.0 h1:t/Qur3vKSkUCcDVaSumWF2PKHt85pc7fRvFuoVT8qFU= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.32.0/go.mod h1:Rl61tySSdcOJWoEgYZVtmnKdA0GeKrSqkHC1t+91CH8= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0 h1:Vh5HayB/0HHfOQA7Ctx69E/Y/DcQSMPpKANYVMQ7fBA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0/go.mod h1:cpgtDBaqD/6ok/UG0jT15/uKjAY8mRA53diogHBg3UI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0 h1:5pojmb1U1AogINhN3SurB+zm/nIcusopeBNp42f45QM= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.33.0/go.mod h1:57gTHJSE5S1tqg+EKsLPlTWhpHMsWlVmer+LA926XiA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.32.0 h1:cMyu9O88joYEaI47CnQkxO1XZdpoTF9fEnW2duIddhw= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.32.0/go.mod h1:6Am3rn7P9TVVeXYG+wtcGE7IE1tsQ+bP3AuWcKt/gOI= +go.opentelemetry.io/otel/exporters/prometheus v0.54.0 h1:rFwzp68QMgtzu9PgP3jm9XaMICI6TsofWWPcBDKwlsU= +go.opentelemetry.io/otel/exporters/prometheus v0.54.0/go.mod h1:QyjcV9qDP6VeK5qPyKETvNjmaaEc7+gqjh4SS0ZYzDU= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.8.0 h1:CHXNXwfKWfzS65yrlB2PVds1IBZcdsX8Vepy9of0iRU= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.8.0/go.mod h1:zKU4zUgKiaRxrdovSS2amdM5gOc59slmo/zJwGX+YBg= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.32.0 h1:SZmDnHcgp3zwlPBS2JX2urGYe/jBKEIT6ZedHRUyCz8= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.32.0/go.mod h1:fdWW0HtZJ7+jNpTKUR0GpMEDP69nR8YBJQxNiVCE3jk= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.32.0 h1:cC2yDI3IQd0Udsux7Qmq8ToKAx1XCilTQECZ0KDZyTw= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.32.0/go.mod h1:2PD5Ex6z8CFzDbTdOlwyNIUywRr1DN0ospafJM1wJ+s= +go.opentelemetry.io/otel/log v0.8.0 h1:egZ8vV5atrUWUbnSsHn6vB8R21G2wrKqNiDt3iWertk= +go.opentelemetry.io/otel/log v0.8.0/go.mod h1:M9qvDdUTRCopJcGRKg57+JSQ9LgLBrwwfC32epk5NX8= +go.opentelemetry.io/otel/metric v1.33.0 h1:r+JOocAyeRVXD8lZpjdQjzMadVZp2M4WmQ+5WtEnklQ= +go.opentelemetry.io/otel/metric v1.33.0/go.mod h1:L9+Fyctbp6HFTddIxClbQkjtubW6O9QS3Ann/M82u6M= +go.opentelemetry.io/otel/sdk v1.33.0 h1:iax7M131HuAm9QkZotNHEfstof92xM+N8sr3uHXc2IM= +go.opentelemetry.io/otel/sdk v1.33.0/go.mod h1:A1Q5oi7/9XaMlIWzPSxLRWOI8nG3FnzHJNbiENQuihM= +go.opentelemetry.io/otel/sdk/log v0.8.0 h1:zg7GUYXqxk1jnGF/dTdLPrK06xJdrXgqgFLnI4Crxvs= +go.opentelemetry.io/otel/sdk/log v0.8.0/go.mod h1:50iXr0UVwQrYS45KbruFrEt4LvAdCaWWgIrsN3ZQggo= +go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU= +go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ= +go.opentelemetry.io/otel/trace v1.33.0 h1:cCJuF7LRjUFso9LPnEAHJDB2pqzp+hbO8eu1qqW2d/s= +go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck= +go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= +go.opentelemetry.io/proto/otlp v1.4.0 h1:TA9WRvW6zMwP+Ssb6fLoUIuirti1gGbP28GcKG1jgeg= +go.opentelemetry.io/proto/otlp v1.4.0/go.mod h1:PPBWZIP98o2ElSqI35IHfu7hIhSwvc5N38Jw8pXuGFY= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= +go.yaml.in/yaml/v3 v3.0.3 h1:bXOww4E/J3f66rav3pX3m8w6jDE4knZjGOw8b5Y6iNE= +go.yaml.in/yaml/v3 v3.0.3/go.mod h1:tBHosrYAkRZjRAOREWbDnBXUf08JOwYq++0QNwQiWzI= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q= +golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4= +golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3/go.mod h1:NOZ3BPKG0ec/BKJQgnvsSFpcKLM5xXVWnvZS97DWHgE= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20201208152932-35266b937fa6/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210216034530-4410531fe030/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210607152325-775e3b0c77b9/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20220302094943-723b81ca9867/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY= +golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= +golang.org/x/oauth2 v0.5.0/go.mod h1:9/XBHVqLaWO3/BRHs5jbpYCnOZVjj5V0ndyaAM7KB4I= +golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= +golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI= +golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= +golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210304124612-50617c2ba197/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc= +golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU= +golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= +golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= +golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= +golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190927191325-030b2cf1153e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ= +golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= +gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= +gonum.org/v1/gonum v0.9.3/go.mod h1:TZumC3NeyVQskjXqmyWt4S3bINhy7B4eYwW69EbyX+0= +gonum.org/v1/gonum v0.11.0/go.mod h1:fSG4YDCxxUZQJ7rKsQrj0gMOg00Il0Z96/qMA4bVQhA= +gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= +gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= +gonum.org/v1/plot v0.9.0/go.mod h1:3Pcqqmp6RHvJI72kgb8fThyUnav364FOsdDo2aGW5lY= +gonum.org/v1/plot v0.10.1/go.mod h1:VZW5OlhkL1mysU9vaqNHnsy86inf6Ot+jB3r+BczCEo= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= +google.golang.org/api v0.106.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.107.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.108.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.110.0/go.mod h1:7FC4Vvx1Mooxh8C5HWjzZHcavuS2f6pmJpZx60ca7iI= +google.golang.org/api v0.111.0/go.mod h1:qtFHvU9mhgTJegR31csQ+rwxyUTHOKFqCKWp1J0fdw0= +google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221109142239-94d6d90a7d66/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201204527-e3fa12d562f3/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230112194545-e10362b5ecf9/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230113154510-dbe35b8444a5/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230123190316-2c411cf9d197/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230125152338-dcaf20b6aeaa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230127162408-596548ed4efa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230216225411-c8e22ba71e44/go.mod h1:8B0gmkoRebU8ukX6HP+4wrVQUY1+6PkQ44BSyIlflHA= +google.golang.org/genproto v0.0.0-20230222225845-10f96fb3dbec/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230223222841-637eb2293923/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230303212802-e74f57abe488/go.mod h1:TvhZT5f700eVlTNwND1xoEZQeWTB2RY/65kplwl/bFA= +google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230320184635-7606e756e683/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230323212658-478b75c54725/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230330154414-c0448cd141ea/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230331144136-dcfb400f0633/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230525234025-438c736192d0/go.mod h1:9ExIQyXL5hZrHzQceCwuSYwZZ5QZBazOcprJ5rgs3lY= +google.golang.org/genproto v0.0.0-20230526161137-0005af68ea54/go.mod h1:zqTuNwFlFRsw5zIts5VnzLQxSRqh+CGOTVMlYbY0Eyk= +google.golang.org/genproto v0.0.0-20240123012728-ef4313101c80 h1:KAeGQVN3M9nD0/bQXnr/ClcEMJ968gUXJQ9pwfSynuQ= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234020-1aefcd67740a/go.mod h1:ts19tUU+Z0ZShN1y3aPyq2+O3d5FUNNgT6FtOzmrNn8= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234035-dd9d682886f9/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 h1:CkkIfIt50+lT6NHAVoRYEyAvQGFM7xEwXUUywFvEb3Q= +google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576/go.mod h1:1R3kvZ1dtP3+4p4d3G8uJ8rFk/fWlScl38vanWACI08= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234015-3fc162c6f38a/go.mod h1:xURIpW9ES5+/GZhnV6beoEtxQrnkRGIfP5VQG2tCBLc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 h1:8ZmaLZE4XWrtU3MyClkYqqtl6Oegr3235h7jxsDyqCY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g= +google.golang.org/grpc v1.68.1 h1:oI5oTa11+ng8r8XMMN7jAOmWfPZWbYpCFaMUTACxkM0= +google.golang.org/grpc v1.68.1/go.mod h1:+q1XYFJjShcqn0QZHvCyeR4CXPA+llXIeUIfIe00waw= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM= +google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= +gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o= +gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g= +helm.sh/helm/v3 v3.18.5 h1:Cc3Z5vd6kDrZq9wO9KxKLNEickiTho6/H/dBNRVSos4= +helm.sh/helm/v3 v3.18.5/go.mod h1:L/dXDR2r539oPlFP1PJqKAC1CUgqHJDLkxKpDGrWnyg= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= +k8s.io/api v0.33.3 h1:SRd5t//hhkI1buzxb288fy2xvjubstenEKL9K51KBI8= +k8s.io/api v0.33.3/go.mod h1:01Y/iLUjNBM3TAvypct7DIj0M0NIZc+PzAHCIo0CYGE= +k8s.io/apiextensions-apiserver v0.33.3 h1:qmOcAHN6DjfD0v9kxL5udB27SRP6SG/MTopmge3MwEs= +k8s.io/apiextensions-apiserver v0.33.3/go.mod h1:oROuctgo27mUsyp9+Obahos6CWcMISSAPzQ77CAQGz8= +k8s.io/apimachinery v0.33.3 h1:4ZSrmNa0c/ZpZJhAgRdcsFcZOw1PQU1bALVQ0B3I5LA= +k8s.io/apimachinery v0.33.3/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM= +k8s.io/client-go v0.33.3 h1:M5AfDnKfYmVJif92ngN532gFqakcGi6RvaOF16efrpA= +k8s.io/client-go v0.33.3/go.mod h1:luqKBQggEf3shbxHY4uVENAxrDISLOarxpTKMiUuujg= +k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= +k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8= +k8s.io/kubectl v0.33.3 h1:r/phHvH1iU7gO/l7tTjQk2K01ER7/OAJi8uFHHyWSac= +k8s.io/kubectl v0.33.3/go.mod h1:euj2bG56L6kUGOE/ckZbCoudPwuj4Kud7BR0GzyNiT0= +k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 h1:M3sRQVHv7vB20Xc2ybTt7ODCeFj6JSWYFzOFnYeS6Ro= +k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.2/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.3/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc= +modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw= +modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.8/go.mod h1:zNjwkizS+fIFDrDjIAgBSCLkWbJuHF+ar3QRn+Z9aws= +modernc.org/ccgo/v3 v3.16.9/go.mod h1:zNMzC9A9xeNUepy6KuZBbugn3c0Mc9TeiJO4lgvkJDo= +modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= +modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= +modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A= +modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU= +modernc.org/libc v1.16.17/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU= +modernc.org/libc v1.16.19/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.17.0/go.mod h1:XsgLldpP4aWlPlsjqKRdHPqCxCjISdHfM/yeWC5GyW0= +modernc.org/libc v1.17.1/go.mod h1:FZ23b+8LjxZs7XtFMbSzL/EhPxNbfZbErxEHc7cbD9s= +modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.0/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.1/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/sqlite v1.18.1/go.mod h1:6ho+Gow7oX5V+OiOQ6Tr4xeqbx13UZ6t+Fw9IRUG4d4= +modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw= +modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw= +modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw= +modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8= +oras.land/oras-go v1.2.7 h1:KF9rBAtKYMGB5gjgHV5XquUfYDER3ecQBEXjdI7KZWI= +oras.land/oras-go v1.2.7/go.mod h1:WVpIPbm82xjWT/GJU3TqZ0y9Ctj3DGco4wLYvGdOVvA= +oras.land/oras-go/v2 v2.6.0 h1:X4ELRsiGkrbeox69+9tzTu492FMUu7zJQW6eJU+I2oc= +oras.land/oras-go/v2 v2.6.0/go.mod h1:magiQDfG6H1O9APp+rOsvCPcW1GD2MM7vgnKY0Y+u1o= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo= +sigs.k8s.io/kustomize/api v0.19.0 h1:F+2HB2mU1MSiR9Hp1NEgoU2q9ItNOaBJl0I4Dlus5SQ= +sigs.k8s.io/kustomize/api v0.19.0/go.mod h1:/BbwnivGVcBh1r+8m3tH1VNxJmHSk1PzP5fkP6lbL1o= +sigs.k8s.io/kustomize/kyaml v0.19.0 h1:RFge5qsO1uHhwJsu3ipV7RNolC7Uozc0jUBC/61XSlA= +sigs.k8s.io/kustomize/kyaml v0.19.0/go.mod h1:FeKD5jEOH+FbZPpqUghBP8mrLjJ3+zD3/rf9NNu1cwY= +sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU= +sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= +sigs.k8s.io/yaml v1.5.0 h1:M10b2U7aEUY6hRtU870n2VTPgR5RZiL/I6Lcc2F4NUQ= +sigs.k8s.io/yaml v1.5.0/go.mod h1:wZs27Rbxoai4C0f8/9urLZtZtF3avA3gKvGyPdDqTO4= + +GOSUM_EOF + +cd "$PREFETCH_DIR" + +# Fill the module cache with the pinned dependency graph. -modfile points at the +# inline-generated manifest so the download never touches the repository tree. +"$GO" mod download -modfile "$PREFETCH_DIR/go.mod" diff --git a/kubecfg--kubecfg.64da3e7/tests/executable b/kubecfg--kubecfg.64da3e7/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..f939ff0b8c3257ce56b56348d11042eefddd0ff6 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78332e621c5a5a4159e71a94e66c3bd6727aae6d2dec3e45d1cc35b1c30a4e33 +size 76726901 diff --git a/kubecfg--kubecfg.64da3e7/tests/harbor_prepare_download_env.sh b/kubecfg--kubecfg.64da3e7/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kubecfg--kubecfg.64da3e7/tests/programgym-go.tar.gz b/kubecfg--kubecfg.64da3e7/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubecfg--kubecfg.64da3e7/tests/programgym_evaluator.py b/kubecfg--kubecfg.64da3e7/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kubecfg--kubecfg.64da3e7/tests/programgym_task.json b/kubecfg--kubecfg.64da3e7/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..19cec4e1a043ba3907742d3ccf5f961bd6dc683e --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/programgym_task.json @@ -0,0 +1,1059 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_eval.test_alpha_flag_enables_eval", + "eval.tests.test_eval.test_eval_expr_inline_yaml", + "eval.tests.test_eval.test_eval_expr_json_format", + "eval.tests.test_eval.test_eval_missing_filename_errors", + "eval.tests.test_eval.test_eval_requires_alpha", + "eval.tests.test_eval.test_eval_show_keys_lists_keys", + "eval.tests.test_eval.test_eval_trace_accepted", + "eval.tests.test_eval.test_eval_undefined_extvar_errors", + "eval.tests.test_eval.test_ext_code_injects_jsonnet_expr", + "eval.tests.test_eval.test_ext_str_file_missing_equals_errors", + "eval.tests.test_eval.test_ext_str_file_reads_value", + "eval.tests.test_eval.test_ext_str_injects_value", + "eval.tests.test_eval.test_ext_str_missing_env_var_errors", + "eval.tests.test_eval.test_ext_str_reads_env_var", + "eval.tests.test_eval.test_jpath_flag_adds_import_search", + "eval.tests.test_eval.test_kubecfg_jpath_env_sets_search", + "eval.tests.test_eval.test_tla_str_injects_function_args", + "eval.tests.test_flags.test_jpath_env_used_when_valid_last", + "eval.tests.test_flags.test_jurl_flag_parses_as_string_array", + "eval.tests.test_flags.test_label_flags_accepted_no_cluster", + "eval.tests.test_flags.test_resolver_flags_parse", + "eval.tests.test_flags.test_verbose_count_flag_parses[flag_args0]", + "eval.tests.test_flags.test_verbose_count_flag_parses[flag_args1]", + "eval.tests.test_flags.test_verbose_count_flag_parses[flag_args2]", + "eval.tests.test_flags.test_verbose_count_flag_parses[flag_args3]", + "eval.tests.test_flags.test_verbose_zero_default_still_runs", + "eval.tests.test_pack_httpd.test_httpd_alpha_invalid_request_body_returns_500", + "eval.tests.test_pack_httpd.test_httpd_alpha_missing_hook_file_fails_on_read", + "eval.tests.test_pack_httpd.test_httpd_alpha_no_args_requires_filename", + "eval.tests.test_pack_httpd.test_httpd_alpha_non_post_method_return_405", + "eval.tests.test_pack_httpd.test_httpd_alpha_post_echoes_json_object_body", + "eval.tests.test_pack_httpd.test_httpd_alpha_serves_post_rendering_hook", + "eval.tests.test_pack_httpd.test_pack_alpha_missing_root_import_errors", + "eval.tests.test_pack_httpd.test_pack_alpha_output_bundles_imported_dependencies", + "eval.tests.test_pack_httpd.test_pack_alpha_output_directory_target_errors", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags0]", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags1]", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags2]", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags3]", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags4]", + "eval.tests.test_pack_httpd.test_pack_alpha_output_writes_gzip_tar[extra_flags5]", + "eval.tests.test_pack_httpd.test_pack_alpha_without_output_reaches_oci_push_and_fails", + "eval.tests.test_pack_httpd.test_pack_takes_exactly_two_positional_args_before_alpha", + "eval.tests.test_root.test_completion_guesses_shell_from_env", + "eval.tests.test_root.test_completion_known_shells[bash-# bash completion for kubecfg]", + "eval.tests.test_root.test_completion_known_shells[fish-# fish completion for kubecfg]", + "eval.tests.test_root.test_completion_known_shells[zsh-#compdef kubecfg]", + "eval.tests.test_root.test_completion_unknown_shell_errors", + "eval.tests.test_root.test_each_subcommand_help[completion]", + "eval.tests.test_root.test_each_subcommand_help[delete]", + "eval.tests.test_root.test_each_subcommand_help[diff]", + "eval.tests.test_root.test_each_subcommand_help[eval]", + "eval.tests.test_root.test_each_subcommand_help[httpd]", + "eval.tests.test_root.test_each_subcommand_help[pack]", + "eval.tests.test_root.test_each_subcommand_help[show]", + "eval.tests.test_root.test_each_subcommand_help[traceback]", + "eval.tests.test_root.test_each_subcommand_help[update]", + "eval.tests.test_root.test_each_subcommand_help[validate]", + "eval.tests.test_root.test_each_subcommand_help[version]", + "eval.tests.test_root.test_help_command_lists_all_subcommands", + "eval.tests.test_root.test_help_flag_prints_usage", + "eval.tests.test_root.test_no_args_prints_help_to_stdout", + "eval.tests.test_root.test_unknown_command_errors", + "eval.tests.test_root.test_unknown_root_flag_errors", + "eval.tests.test_root.test_unknown_subcommand_flag_errors", + "eval.tests.test_root.test_version_prints_three_version_lines", + "eval.tests.test_root.test_version_rejects_extra_args", + "eval.tests.test_show.test_overlay_code_file_requires_alpha", + "eval.tests.test_show.test_overlay_code_file_success", + "eval.tests.test_show.test_overlay_code_requires_alpha", + "eval.tests.test_show.test_overlay_code_success", + "eval.tests.test_show.test_overlay_flags_mutually_exclusive", + "eval.tests.test_show.test_show_default_yaml", + "eval.tests.test_show.test_show_exec_inline_code", + "eval.tests.test_show.test_show_explicit_formats[json]", + "eval.tests.test_show.test_show_explicit_formats[yaml]", + "eval.tests.test_show.test_show_export_dir_filename_extension", + "eval.tests.test_show.test_show_export_dir_non_empty_errors", + "eval.tests.test_show.test_show_export_dir_writes_file", + "eval.tests.test_show.test_show_inline_exec_short_flag", + "eval.tests.test_show.test_show_invalid_format_errors", + "eval.tests.test_show.test_show_json_format", + "eval.tests.test_show.test_show_missing_input_file_errors", + "eval.tests.test_show.test_show_provenance_annotations", + "eval.tests.test_show.test_show_reorder_default_empty_accepted", + "eval.tests.test_show.test_show_reorder_invalid_errors", + "eval.tests.test_show.test_show_reorder_server_needs_kubeconfig", + "eval.tests.test_show.test_show_syntax_error_reported", + "eval.tests.test_show.test_show_undefined_extvar_errors", + "eval.tests.test_subcommands.test_alpha_gate_commands[cmd0]", + "eval.tests.test_subcommands.test_alpha_gate_commands[cmd1]", + "eval.tests.test_subcommands.test_alpha_gate_commands[cmd2]", + "eval.tests.test_subcommands.test_cluster_command_kubeconfig_error[delete]", + "eval.tests.test_subcommands.test_cluster_command_kubeconfig_error[diff]", + "eval.tests.test_subcommands.test_cluster_command_kubeconfig_error[update]", + "eval.tests.test_subcommands.test_cluster_command_kubeconfig_error[validate]", + "eval.tests.test_subcommands.test_diff_strategy_flag_parsed", + "eval.tests.test_subcommands.test_grace_period_flag_parsed", + "eval.tests.test_subcommands.test_pack_exact_args_enforced", + "eval.tests.test_subcommands.test_pack_wrong_arg_count", + "eval.tests.test_subcommands.test_qps_limit_flag_parsed", + "eval.tests.test_subcommands.test_show_with_explicit_kubeconfig_ignores_missing_file_for_read", + "eval.tests.test_subcommands.test_traceback_exact_args_enforced", + "eval.tests.test_subcommands.test_update_flag_parse_before_client", + "eval.tests.test_traceback_validate.test_traceback_alpha_all_flag_binds", + "eval.tests.test_traceback_validate.test_traceback_alpha_jsonnetvm_missing_envvar", + "eval.tests.test_traceback_validate.test_traceback_alpha_missing_input_file_errors", + "eval.tests.test_traceback_validate.test_traceback_alpha_success_maps_yaml_line[traceback_input.yaml:1-$.apiVersion-cm.jsonnet:6]", + "eval.tests.test_traceback_validate.test_traceback_alpha_success_maps_yaml_line[traceback_input.yaml:2-$.data-cm.jsonnet:9]", + "eval.tests.test_traceback_validate.test_traceback_arg_non_numeric_line_errors", + "eval.tests.test_traceback_validate.test_traceback_arg_without_colon_errors", + "eval.tests.test_traceback_validate.test_traceback_too_many_args_errors", + "eval.tests.test_traceback_validate.test_validate_empty_input_succeeds_no_objects", + "eval.tests.test_traceback_validate.test_validate_missing_input_read_errors", + "eval.tests.test_traceback_validate.test_validate_reaches_run_via_dead_server_kubeconfig", + "eval.tests.test_traceback_validate.test_validate_repeat_eval_and_ignore_unknown_flags", + "eval.tests.test_update_delete.test_delete_grace_period_rejects_non_integer", + "eval.tests.test_update_delete.test_delete_grace_period_variants_reach_run[grace_flag0]", + "eval.tests.test_update_delete.test_delete_grace_period_variants_reach_run[grace_flag1]", + "eval.tests.test_update_delete.test_delete_grace_period_variants_reach_run[grace_flag2]", + "eval.tests.test_update_delete.test_delete_grace_period_variants_reach_run[grace_flag3]", + "eval.tests.test_update_delete.test_delete_kubeconfig_reaches_run", + "eval.tests.test_update_delete.test_delete_object_identity_from_input", + "eval.tests.test_update_delete.test_update_gc_all_namespaces_false_uses_default_ns", + "eval.tests.test_update_delete.test_update_gc_all_namespaces_true_default_is_namespace_all", + "eval.tests.test_update_delete.test_update_gc_flags_reach_validate[extra_flags0]", + "eval.tests.test_update_delete.test_update_gc_flags_reach_validate[extra_flags1]", + "eval.tests.test_update_delete.test_update_gc_flags_reach_validate[extra_flags2]", + "eval.tests.test_update_delete.test_update_grace_dryrun_confirm_no_cluster_skip", + "eval.tests.test_update_delete.test_update_ignore_unknown_flag_reaches_validate", + "eval.tests.test_update_delete.test_update_kubeconfig_reaches_validate_block", + "eval.tests.test_update_delete.test_update_namespace_override_reaches_default_ns", + "eval.tests.test_update_delete.test_update_object_identity_from_input", + "eval.tests.test_update_delete.test_update_state_flags_all_reach_validate[extra_flags0]", + "eval.tests.test_update_delete.test_update_state_flags_all_reach_validate[extra_flags1]", + "eval.tests.test_update_delete.test_update_state_flags_all_reach_validate[extra_flags2]", + "eval.tests.test_update_delete.test_update_state_flags_all_reach_validate[extra_flags3]", + "eval.tests.test_update_delete.test_update_validate_false_skips_to_run", + "eval.tests.test_update_delete.test_update_validate_false_with_gc_all_ns_false" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_eval.test_eval_default_expr_dollar", + "eval.tests.test_eval.test_eval_default_format_is_yaml", + "eval.tests.test_eval.test_eval_expr_field_access", + "eval.tests.test_eval.test_eval_expr_string_literal", + "eval.tests.test_eval.test_eval_missing_filename", + "eval.tests.test_eval.test_eval_missing_tla_arg_error", + "eval.tests.test_eval.test_eval_output_formats[json]", + "eval.tests.test_eval.test_eval_output_formats[yaml]", + "eval.tests.test_eval.test_eval_requires_alpha", + "eval.tests.test_eval.test_eval_show_keys_json", + "eval.tests.test_eval.test_eval_tla_code_forwarding", + "eval.tests.test_eval.test_eval_tla_forwarding", + "eval.tests.test_eval.test_eval_trace_flag", + "eval.tests.test_eval.test_eval_unsupported_format", + "eval.tests.test_eval.test_eval_yaml_array_field", + "eval.tests.test_eval.test_eval_yaml_scalar", + "eval.tests.test_eval_scalars.test_eval_json_scalar_expr[null]", + "eval.tests.test_eval_scalars.test_eval_json_scalar_expr[true]", + "eval.tests.test_eval_scalars.test_eval_malformed_expr_is_error", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[false]", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[float]", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[int]", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[null]", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[string]", + "eval.tests.test_eval_scalars.test_eval_yaml_scalar_expr[true]", + "eval.tests.test_httpd.test_httpd_get_is_method_not_allowed", + "eval.tests.test_httpd.test_httpd_hook_evaluation_error_returns_500", + "eval.tests.test_httpd.test_httpd_hook_with_fields", + "eval.tests.test_httpd.test_httpd_malformed_body_returns_500", + "eval.tests.test_httpd.test_httpd_missing_hook_file", + "eval.tests.test_httpd.test_httpd_multiple_sequential_posts", + "eval.tests.test_httpd.test_httpd_post_content_type", + "eval.tests.test_httpd.test_httpd_post_renders_hook", + "eval.tests.test_httpd.test_httpd_put_is_method_not_allowed", + "eval.tests.test_httpd.test_httpd_requires_alpha", + "eval.tests.test_input_dispatch.test_show_export_dir_resource_index_multi", + "eval.tests.test_input_dispatch.test_show_json_input_renders", + "eval.tests.test_input_dispatch.test_show_json_list_input_flattens", + "eval.tests.test_input_dispatch.test_show_multiple_files_json_separator", + "eval.tests.test_input_dispatch.test_show_multiple_files_yaml_framing", + "eval.tests.test_input_dispatch.test_show_unsupported_extension_is_error[cfg-extension]", + "eval.tests.test_input_dispatch.test_show_unsupported_extension_is_error[stdin-dash]", + "eval.tests.test_input_dispatch.test_show_yaml_input_roundtrip", + "eval.tests.test_pack.test_pack_argc_errors[args0-accepts 2 arg(s), received 0]", + "eval.tests.test_pack.test_pack_argc_errors[args1-accepts 2 arg(s), received 3]", + "eval.tests.test_pack.test_pack_deduplicates_member_prefix", + "eval.tests.test_pack.test_pack_dependency_content_roundtrip", + "eval.tests.test_pack.test_pack_missing_root_file_is_error", + "eval.tests.test_pack.test_pack_missing_second_arg_is_error", + "eval.tests.test_pack.test_pack_output_creates_archive", + "eval.tests.test_pack.test_pack_output_includes_dependencies", + "eval.tests.test_pack.test_pack_push_annotation_added", + "eval.tests.test_pack.test_pack_push_annotation_edge_values_valid[=onlyvalue-]", + "eval.tests.test_pack.test_pack_push_annotation_edge_values_valid[a=b=c-a]", + "eval.tests.test_pack.test_pack_push_annotation_edge_values_valid[key=-key]", + "eval.tests.test_pack.test_pack_push_config_artifact_type", + "eval.tests.test_pack.test_pack_push_config_blob_contents", + "eval.tests.test_pack.test_pack_push_docs_bad_extension_is_error[md]", + "eval.tests.test_pack.test_pack_push_docs_bad_extension_is_error[txt]", + "eval.tests.test_pack.test_pack_push_docs_bad_extension_is_error[zip]", + "eval.tests.test_pack.test_pack_push_docs_missing_file_is_error", + "eval.tests.test_pack.test_pack_push_docs_tar_gz_layer", + "eval.tests.test_pack.test_pack_push_docs_tgz_layer", + "eval.tests.test_pack.test_pack_push_invalid_annotation_is_error[a]", + "eval.tests.test_pack.test_pack_push_invalid_annotation_is_error[justacolon:alsoish]", + "eval.tests.test_pack.test_pack_push_invalid_annotation_is_error[noeq]", + "eval.tests.test_pack.test_pack_push_invalid_annotation_is_error[novalue]", + "eval.tests.test_pack.test_pack_push_merges_pack_metadata", + "eval.tests.test_pack.test_pack_push_multiple_annotations", + "eval.tests.test_pack.test_pack_push_requires_insecure_registry", + "eval.tests.test_pack.test_pack_push_revision_from_git", + "eval.tests.test_pack.test_pack_push_revision_unknown_outside_git", + "eval.tests.test_pack.test_pack_push_succeeds_against_registry", + "eval.tests.test_pack.test_pack_push_untagged_reference_is_error", + "eval.tests.test_pack.test_pack_requires_alpha", + "eval.tests.test_reorder_overlay.test_overlay_code_file_path_value_deep", + "eval.tests.test_reorder_overlay.test_overlay_code_file_path_value_single", + "eval.tests.test_reorder_overlay.test_overlay_code_path_value_deep_dotted", + "eval.tests.test_reorder_overlay.test_overlay_code_path_value_equals_in_value", + "eval.tests.test_reorder_overlay.test_overlay_code_path_value_nonstring_annotations_is_error", + "eval.tests.test_reorder_overlay.test_overlay_code_path_value_single", + "eval.tests.test_reorder_overlay.test_overlay_code_path_value_string_label", + "eval.tests.test_reorder_overlay.test_show_reorder_server_requires_kubeconfig", + "eval.tests.test_reorder_overlay.test_show_reorder_unknown_value_is_error[bogus]", + "eval.tests.test_reorder_overlay.test_show_reorder_unknown_value_is_error[lightly]", + "eval.tests.test_reorder_overlay.test_show_reorder_unknown_value_is_error[quantum]", + "eval.tests.test_resolver.test_readobjects_duplicate_resource_conflict", + "eval.tests.test_resolver.test_readobjects_exact_duplicates_elided", + "eval.tests.test_resolver.test_resolve_image_invalid_name_is_error", + "eval.tests.test_resolver.test_resolve_image_noop_success", + "eval.tests.test_resolver.test_resolve_image_registry_failure_error_action", + "eval.tests.test_resolver.test_resolve_image_registry_failure_ignore_action", + "eval.tests.test_resolver.test_resolve_image_registry_failure_warn_action", + "eval.tests.test_resolver.test_show_jurl_http_host_escape", + "eval.tests.test_resolver.test_show_jurl_malformed_url_is_error", + "eval.tests.test_resolver.test_show_jurl_without_trailing_slash_searches", + "eval.tests.test_resolver.test_show_resolve_error_action_error_accepted", + "eval.tests.test_resolver.test_show_resolve_error_action_ignore_accepted", + "eval.tests.test_resolver.test_show_resolve_error_action_unknown_falls_back_to_warn", + "eval.tests.test_resolver.test_show_resolve_images_explicit_noop", + "eval.tests.test_resolver.test_show_resolve_images_registry", + "eval.tests.test_resolver.test_show_resolve_images_unknown_falls_back_to_noop", + "eval.tests.test_show.test_show_bad_filename_template_is_error", + "eval.tests.test_show.test_show_export_dir_extension_override", + "eval.tests.test_show.test_show_export_dir_incremental_error", + "eval.tests.test_show.test_show_export_dir_nonempty_is_error", + "eval.tests.test_show.test_show_export_dir_writes_files[default-fmt]", + "eval.tests.test_show.test_show_export_dir_writes_files[nested-dir]", + "eval.tests.test_show.test_show_export_dir_writes_files[resource-index]", + "eval.tests.test_show.test_show_expression_error_is_reported", + "eval.tests.test_show.test_show_flattens_v1_list", + "eval.tests.test_show.test_show_json_multiple_objects_framed", + "eval.tests.test_show.test_show_missing_file_is_error", + "eval.tests.test_show.test_show_no_input_is_ok", + "eval.tests.test_show.test_show_provenance_annotations", + "eval.tests.test_show.test_show_relative_input_path", + "eval.tests.test_show.test_show_removes_duplicate_objects", + "eval.tests.test_show.test_show_single_object_renders[default]", + "eval.tests.test_show.test_show_single_object_renders[long-json]", + "eval.tests.test_show.test_show_single_object_renders[long-yaml]", + "eval.tests.test_show.test_show_single_object_renders[short-json]", + "eval.tests.test_show.test_show_single_object_renders[short-yaml]", + "eval.tests.test_show.test_show_unknown_format_is_error", + "eval.tests.test_show.test_show_yaml_all_objects_present[first]", + "eval.tests.test_show.test_show_yaml_all_objects_present[second]", + "eval.tests.test_show.test_show_yaml_common_kinds[configmap-data]", + "eval.tests.test_show.test_show_yaml_common_kinds[service-spec]", + "eval.tests.test_show.test_show_yaml_is_deterministic", + "eval.tests.test_traceback.test_traceback_bad_line_number_is_error", + "eval.tests.test_traceback.test_traceback_different_lines_differ", + "eval.tests.test_traceback.test_traceback_emits_source_location", + "eval.tests.test_traceback.test_traceback_empty_argument_no_colon", + "eval.tests.test_traceback.test_traceback_invalid_line_numbers[ ]", + "eval.tests.test_traceback.test_traceback_invalid_line_numbers[+]", + "eval.tests.test_traceback.test_traceback_invalid_line_numbers[12abc]", + "eval.tests.test_traceback.test_traceback_invalid_line_numbers[]", + "eval.tests.test_traceback.test_traceback_invalid_line_numbers[abc]", + "eval.tests.test_traceback.test_traceback_invalid_yaml_syntax", + "eval.tests.test_traceback.test_traceback_logs_target_path_on_stderr", + "eval.tests.test_traceback.test_traceback_metadata_field_wrong_type", + "eval.tests.test_traceback.test_traceback_missing_provenance_annotation", + "eval.tests.test_traceback.test_traceback_no_colon_is_error", + "eval.tests.test_traceback.test_traceback_nonexistent_file", + "eval.tests.test_traceback.test_traceback_provenance_file_annotation_missing", + "eval.tests.test_traceback.test_traceback_provenance_path_annotation_missing", + "eval.tests.test_traceback.test_traceback_read_errors_with_empty_filename", + "eval.tests.test_traceback.test_traceback_requires_alpha", + "eval.tests.test_traceback.test_traceback_show_all_flag", + "eval.tests.test_vars.test_bare_ext_str_missing_env_is_error", + "eval.tests.test_vars.test_bare_ext_str_reads_env", + "eval.tests.test_vars.test_ext_code_evaluates_jsonnet", + "eval.tests.test_vars.test_ext_code_file_imported_as_code", + "eval.tests.test_vars.test_ext_code_undefined_var_error", + "eval.tests.test_vars.test_ext_str_eq_in_value", + "eval.tests.test_vars.test_ext_str_file_imported_as_string", + "eval.tests.test_vars.test_ext_str_file_missing_equals", + "eval.tests.test_vars.test_ext_str_literal[ext-str-long]", + "eval.tests.test_vars.test_ext_str_literal[ext-str-short]", + "eval.tests.test_vars.test_file_source_var_missing_file_is_error[ext-code-file]", + "eval.tests.test_vars.test_file_source_var_missing_file_is_error[ext-str-file]", + "eval.tests.test_vars.test_file_source_var_missing_file_is_error[tla-code-file]", + "eval.tests.test_vars.test_file_source_var_missing_file_is_error[tla-str-file]", + "eval.tests.test_vars.test_tla_code_file", + "eval.tests.test_vars.test_tla_literal_types[tla-code]", + "eval.tests.test_vars.test_tla_literal_types[tla-str]", + "eval.tests.test_vars.test_tla_ordering_independent", + "eval.tests.test_vars.test_tla_str_file", + "eval.tests.test_vm.test_exec_inline_object", + "eval.tests.test_vm.test_jpath_env_search", + "eval.tests.test_vm.test_jpath_flag_search", + "eval.tests.test_vm.test_missing_import_error", + "eval.tests.test_vm.test_overlay_code_and_file_mutually_exclusive", + "eval.tests.test_vm.test_overlay_code_composes[field-replacement]", + "eval.tests.test_vm.test_overlay_code_composes[object-composition]", + "eval.tests.test_vm.test_overlay_code_file_libsonnet", + "eval.tests.test_vm.test_overlay_code_file_requires_alpha", + "eval.tests.test_vm.test_overlay_code_file_yaml", + "eval.tests.test_vm.test_overlay_code_requires_alpha", + "eval.tests.test_vm.test_readobject_flatten_and_dedup" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_acquire_binary.test_binary_url_and_importbin_share_cache_key", + "eval.tests.test_acquire_binary.test_binary_url_prefix_alpha_import", + "eval.tests.test_acquire_binary.test_importbin_byte_array[-expected0]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[AB-expected2]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[Z-expected1]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[\\x00-expected3]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[\\x01\\x02\\x03-expected5]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[\\xff-expected4]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[\\xff\\x00\\xff-expected7]", + "eval.tests.test_acquire_binary.test_importbin_byte_array[abc-expected6]", + "eval.tests.test_acquire_binary.test_importbin_bytes_with_commas_and_boundaries", + "eval.tests.test_acquire_binary.test_importbin_multiple_files_isolated", + "eval.tests.test_acquire_binary.test_importbin_same_path_cache_hit", + "eval.tests.test_acquire_binary.test_importbin_used_in_show_object", + "eval.tests.test_acquire_http.test_http_import_not_found_enumerates_candidates", + "eval.tests.test_acquire_http.test_http_import_resolves_from_jurl", + "eval.tests.test_acquire_http.test_http_import_server_error_reported", + "eval.tests.test_acquire_http.test_http_importbin_bytes", + "eval.tests.test_acquire_http.test_oci_import_is_normalized", + "eval.tests.test_acquire_import.test_import_internal_lib_parse_json", + "eval.tests.test_acquire_import.test_import_internal_lib_parse_yaml", + "eval.tests.test_acquire_import.test_import_jpath_env_var", + "eval.tests.test_acquire_import.test_import_malformed_absolute_path_rejected", + "eval.tests.test_acquire_import.test_import_missing_reports_candidates", + "eval.tests.test_acquire_import.test_import_relative_subdir", + "eval.tests.test_acquire_import.test_import_via_jpath_search_path", + "eval.tests.test_acquire_resolver.test_registry_resolver_digest_short_circuits", + "eval.tests.test_acquire_resolver.test_registry_resolver_parse_error", + "eval.tests.test_acquire_resolver.test_resolve_digest_preserved_over_tag", + "eval.tests.test_acquire_resolver.test_resolve_digest_repo_preserved", + "eval.tests.test_acquire_resolver.test_resolve_digest_short_form", + "eval.tests.test_acquire_resolver.test_resolve_explicit_host_port_preserved", + "eval.tests.test_acquire_resolver.test_resolve_explicit_tag_preserved", + "eval.tests.test_acquire_resolver.test_resolve_invalid_image_name_errors", + "eval.tests.test_acquire_resolver.test_resolve_short_name_canonicalises[busybox-docker.io/library/busybox:latest]", + "eval.tests.test_acquire_resolver.test_resolve_short_name_canonicalises[docker.io/library/nginx-docker.io/library/nginx:latest]", + "eval.tests.test_acquire_resolver.test_resolve_short_name_canonicalises[nginx-docker.io/library/nginx:latest]", + "eval.tests.test_acquire_resolver.test_resolve_short_name_canonicalises[nginx:1.14-docker.io/library/nginx:1.14]", + "eval.tests.test_acquire_show.test_show_data_url_direct", + "eval.tests.test_acquire_show.test_show_data_url_jsonnet_scalar_string_errors", + "eval.tests.test_acquire_show.test_show_data_url_percent_encoding", + "eval.tests.test_acquire_show.test_show_empty_yaml_doc_errors", + "eval.tests.test_acquire_show.test_show_exec_data_url", + "eval.tests.test_acquire_show.test_show_exec_jsonnet_error_reported", + "eval.tests.test_acquire_show.test_show_exec_null_produces_no_objects", + "eval.tests.test_acquire_show.test_show_exec_scalar_value_is_not_object[\"a string\"-string]", + "eval.tests.test_acquire_show.test_show_exec_scalar_value_is_not_object[42-float64]", + "eval.tests.test_acquire_show.test_show_exec_scalar_value_is_not_object[true-bool]", + "eval.tests.test_acquire_show.test_show_file_url", + "eval.tests.test_acquire_show.test_show_file_url_missing_target", + "eval.tests.test_acquire_show.test_show_garbage_binary_file_errors", + "eval.tests.test_acquire_show.test_show_http_url_invalid_port", + "eval.tests.test_acquire_show.test_show_http_url_unreachable_server", + "eval.tests.test_acquire_show.test_show_json_file", + "eval.tests.test_acquire_show.test_show_json_object_missing_kind_errors", + "eval.tests.test_acquire_show.test_show_jsonnet_computed_values", + "eval.tests.test_acquire_show.test_show_jsonnet_file", + "eval.tests.test_acquire_show.test_show_libsonnet_file", + "eval.tests.test_acquire_show.test_show_malformed_json_errors", + "eval.tests.test_acquire_show.test_show_malformed_yaml_errors", + "eval.tests.test_acquire_show.test_show_missing_file_errors", + "eval.tests.test_acquire_show.test_show_multidoc_yaml", + "eval.tests.test_acquire_show.test_show_unknown_extension_errors[.cfg]", + "eval.tests.test_acquire_show.test_show_unknown_extension_errors[.toml]", + "eval.tests.test_acquire_show.test_show_unknown_extension_errors[.txt]", + "eval.tests.test_acquire_show.test_show_unknown_extension_errors[]", + "eval.tests.test_acquire_show.test_show_yaml_file", + "eval.tests.test_acquire_walk.test_show_invalid_labels_below_list_item_errors", + "eval.tests.test_acquire_walk.test_show_invalid_string_type_in_annotations_errors", + "eval.tests.test_acquire_walk.test_show_invalid_string_type_in_labels_errors", + "eval.tests.test_acquire_walk.test_show_jsonnet_array_flattens_each_object[five]", + "eval.tests.test_acquire_walk.test_show_jsonnet_array_flattens_each_object[four]", + "eval.tests.test_acquire_walk.test_show_jsonnet_array_flattens_each_object[one]", + "eval.tests.test_acquire_walk.test_show_jsonnet_array_flattens_each_object[three]", + "eval.tests.test_acquire_walk.test_show_jsonnet_array_flattens_each_object[two]", + "eval.tests.test_acquire_walk.test_show_jsonnet_kind_list_expands_items", + "eval.tests.test_acquire_walk.test_show_jsonnet_nested_array", + "eval.tests.test_acquire_walk.test_show_jsonnet_object_under_arbitrary_key", + "eval.tests.test_acquire_walk.test_show_jsonnet_object_under_numeric_key", + "eval.tests.test_acquire_walk.test_show_jsonnet_object_with_scalar_leaf_errors", + "eval.tests.test_acquire_walk.test_show_jsonnet_top_null_ok", + "eval.tests.test_acquire_walk.test_show_jsonnet_top_scalar_errors[\"a string\"-string]", + "eval.tests.test_acquire_walk.test_show_jsonnet_top_scalar_errors[42-float64]", + "eval.tests.test_acquire_walk.test_show_jsonnet_top_scalar_errors[true-bool]", + "eval.tests.test_acquire_walk.test_show_provenance_array_index_path", + "eval.tests.test_acquire_walk.test_show_provenance_list_item_path", + "eval.tests.test_acquire_walk.test_show_provenance_nested_field_path", + "eval.tests.test_acquire_walk.test_show_provenance_no_annotation_without_flag", + "eval.tests.test_acquire_walk.test_show_provenance_sets_file_annotation", + "eval.tests.test_acquire_walk.test_show_provenance_top_level_path", + "eval.tests.test_acquire_walk.test_show_provenance_unsafe_key_bracket_path", + "eval.tests.test_acquire_walk.test_show_valid_string_labels_accepted", + "eval.tests.test_search_up_traceback.test_traceback_bad_line_number_errors", + "eval.tests.test_search_up_traceback.test_traceback_missing_colon_errors", + "eval.tests.test_search_up_traceback.test_traceback_missing_file_errors", + "eval.tests.test_search_up_traceback.test_traceback_reaches_search_up_path", + "eval.tests.test_search_up_traceback.test_traceback_requires_alpha" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_client_discovery.test_delete_cluster_scoped_root_url", + "eval.tests.test_client_discovery.test_delete_custom_default_namespace_flag", + "eval.tests.test_client_discovery.test_delete_discovers_and_resolves_namespaced_url", + "eval.tests.test_client_discovery.test_delete_multi_object_single_refresh", + "eval.tests.test_client_discovery.test_delete_namespaceless_uses_default_namespace", + "eval.tests.test_client_discovery.test_diff_resolves_live_resource_url", + "eval.tests.test_client_discovery.test_show_reorder_server_functional_discovery", + "eval.tests.test_client_discovery.test_validate_cache_hit_for_known_gvk", + "eval.tests.test_client_errors.test_delete_empty_resources_non_transient", + "eval.tests.test_client_errors.test_delete_permanent_500_keeps_retrying", + "eval.tests.test_client_errors.test_delete_transient_grouped_gv[429:1-0-2]", + "eval.tests.test_client_errors.test_delete_transient_grouped_gv[429:2-1-2]", + "eval.tests.test_client_errors.test_delete_transient_grouped_gv[500:1-0-2]", + "eval.tests.test_client_errors.test_delete_transient_grouped_gv[500:2-1-2]", + "eval.tests.test_client_errors.test_delete_transient_grouped_gv[empty-1-1]", + "eval.tests.test_client_errors.test_delete_transient_groupversion_retry[429:1-0-2-False]", + "eval.tests.test_client_errors.test_delete_transient_groupversion_retry[429:2-1-2-True]", + "eval.tests.test_client_errors.test_delete_transient_groupversion_retry[500:1-0-2-False]", + "eval.tests.test_client_errors.test_delete_transient_groupversion_retry[500:2-1-2-True]", + "eval.tests.test_client_errors.test_delete_transient_groupversion_retry[ok-0-1-False]", + "eval.tests.test_client_errors.test_diff_permanent_500_mapping_failure", + "eval.tests.test_client_errors.test_diff_transient_500_recovered", + "eval.tests.test_client_errors.test_show_reorder_server_empty_resources_graceful", + "eval.tests.test_client_errors.test_show_reorder_server_transient_500_recovered", + "eval.tests.test_client_errors.test_validate_transient_500_recovered", + "eval.tests.test_cluster_gated.test_cluster_gated_commands_require_config[cmd_args0]", + "eval.tests.test_cluster_gated.test_cluster_gated_commands_require_config[cmd_args1]", + "eval.tests.test_cluster_gated.test_cluster_gated_commands_require_config[cmd_args2]", + "eval.tests.test_cluster_gated.test_cluster_gated_commands_require_config[cmd_args3]", + "eval.tests.test_cluster_gated.test_diff_requires_config", + "eval.tests.test_cluster_gated.test_show_client_reorder_spelling", + "eval.tests.test_duplicates.test_conflicting_duplicate_rejected", + "eval.tests.test_duplicates.test_duplicate_across_two_files", + "eval.tests.test_duplicates.test_five_distinct_configmaps_all_rendered", + "eval.tests.test_duplicates.test_kinds_separate_duplicate_space", + "eval.tests.test_duplicates.test_literal_duplicate_elided", + "eval.tests.test_duplicates.test_one_provenance_annotation_only_not_literal", + "eval.tests.test_duplicates.test_provenance_only_difference_is_literal", + "eval.tests.test_duplicates.test_same_name_different_namespace_not_duplicate", + "eval.tests.test_duplicates.test_same_name_no_namespace_duplicate", + "eval.tests.test_eval_args.test_eval_default_expr_is_self", + "eval.tests.test_eval_args.test_eval_expr_forms['hello'-hello]", + "eval.tests.test_eval_args.test_eval_expr_forms[[1, 2, 3]-expected2]", + "eval.tests.test_eval_args.test_eval_expr_forms[{n: 1+2, s: 'ab', b: true}-expected3]", + "eval.tests.test_eval_args.test_eval_expr_forms[{x: 1, y: 2}.y-2]", + "eval.tests.test_eval_args.test_eval_jsonnet_constant_error", + "eval.tests.test_eval_args.test_eval_jsonnet_syntax_error", + "eval.tests.test_eval_args.test_eval_missing_file", + "eval.tests.test_eval_args.test_eval_requires_alpha", + "eval.tests.test_eval_args.test_eval_requires_filename", + "eval.tests.test_eval_args.test_eval_show_keys", + "eval.tests.test_eval_args.test_eval_tla_code_run", + "eval.tests.test_eval_args.test_eval_tla_missing_from_nonfunction_file", + "eval.tests.test_eval_args.test_eval_unsupported_format", + "eval.tests.test_eval_args.test_eval_yaml_output", + "eval.tests.test_importers.test_kustomize_import_local_dir_missing", + "eval.tests.test_importers.test_kustomize_import_non_directory", + "eval.tests.test_importers.test_oci_import_connection_refused", + "eval.tests.test_importers.test_oci_import_invalid_registry_ref", + "eval.tests.test_kustomize_render.test_kustomize_alpha_gate_without_flag", + "eval.tests.test_kustomize_render.test_kustomize_empty_kustomization_errors", + "eval.tests.test_kustomize_render.test_kustomize_eval_alpha_gate_precedes_import", + "eval.tests.test_kustomize_render.test_kustomize_full_result_is_json_array", + "eval.tests.test_kustomize_render.test_kustomize_remote_without_kustomization_at_root", + "eval.tests.test_kustomize_render.test_kustomize_render_image_and_container", + "eval.tests.test_kustomize_render.test_kustomize_render_multiple_resources_loop", + "eval.tests.test_kustomize_render.test_kustomize_render_nameprefix_transform", + "eval.tests.test_kustomize_render.test_kustomize_render_namespace_transform", + "eval.tests.test_kustomize_render.test_kustomize_render_single_resource", + "eval.tests.test_meta_object_helpers.test_create_writes_compact_last_applied_annotation", + "eval.tests.test_meta_object_helpers.test_update_existing_invalid_gzip_last_applied_fails", + "eval.tests.test_meta_object_helpers.test_update_existing_malformed_base64_last_applied_fails", + "eval.tests.test_meta_object_helpers.test_update_existing_no_annotation_new_object", + "eval.tests.test_meta_object_helpers.test_update_existing_retains_and_recompacts_last_applied", + "eval.tests.test_meta_object_helpers.test_update_gc_tag_label_write_matrix[prod-None-expected_labels0]", + "eval.tests.test_meta_object_helpers.test_update_gc_tag_label_write_matrix[prod-existing_labels1-expected_labels1]", + "eval.tests.test_meta_object_helpers.test_update_gc_tag_label_write_matrix[prod-existing_labels2-expected_labels2]", + "eval.tests.test_meta_version.test_delete_absent_version_endpoint_uses_default", + "eval.tests.test_meta_version.test_delete_cluster_scoped_service_fqname_no_namespace", + "eval.tests.test_meta_version.test_delete_compare_branch_per_server_minor[1-5]", + "eval.tests.test_meta_version.test_delete_compare_branch_per_server_minor[1-6]", + "eval.tests.test_meta_version.test_delete_compare_branch_per_server_minor[1-8]", + "eval.tests.test_meta_version.test_delete_non_json_version_body_uses_default", + "eval.tests.test_meta_version.test_delete_parses_server_version_and_proceeds[version_payload0-apiVersion: v1\\nkind: ConfigMap\\nmetadata:\\n name: foo\\n namespace: default\\ndata:\\n key: val\\n-Deleting configmap default.foo]", + "eval.tests.test_meta_version.test_delete_parses_server_version_and_proceeds[version_payload1-apiVersion: v1\\nkind: ConfigMap\\nmetadata:\\n name: foo\\n namespace: default\\ndata:\\n key: val\\n-Deleting configmap default.foo]", + "eval.tests.test_meta_version.test_delete_parses_server_version_and_proceeds[version_payload2-apiVersion: v1\\nkind: ConfigMap\\nmetadata:\\n name: foo\\n namespace: default\\ndata:\\n key: val\\n-Deleting configmap default.foo]", + "eval.tests.test_meta_version.test_delete_parses_server_version_and_proceeds[version_payload3-apiVersion: v1\\nkind: ConfigMap\\nmetadata:\\n name: foo\\n namespace: default\\ndata:\\n key: val\\n-Deleting configmap default.foo]", + "eval.tests.test_meta_version.test_delete_parses_server_version_and_proceeds[version_payload4-apiVersion: apiextensions.k8s.io/v1\\nkind: CustomResourceDefinition\\nmetadata:\\n name: widgets.example.com\\nspec:\\n group: example.com\\n names: {kind: Widget, plural: widgets}\\n versions:\\n - name: v1\\n served: true\\n storage: true\\n scope: Namespaced\\n-Deleting customresourcedefinition widgets.example.com]", + "eval.tests.test_meta_version.test_delete_refused_server_uses_default_version", + "eval.tests.test_meta_version.test_delete_unparseable_gitversion_reported", + "eval.tests.test_meta_version.test_validate_cluster_scoped_fqname_no_namespace", + "eval.tests.test_meta_version.test_validate_namespaced_fqname", + "eval.tests.test_nativefuncs.test_escape_string_regex[(x)|[y]-\\\\(x\\\\)\\\\|\\\\[y\\\\]]", + "eval.tests.test_nativefuncs.test_escape_string_regex[a+b?-a\\\\+b\\\\?]", + "eval.tests.test_nativefuncs.test_escape_string_regex[a.b*c-a\\\\.b\\\\*c]", + "eval.tests.test_nativefuncs.test_escape_string_regex[plain-plain]", + "eval.tests.test_nativefuncs.test_escape_string_regex_empty", + "eval.tests.test_nativefuncs.test_manifest_json_indent[0-{\\n\"a\": 1,\\n\"b\": [\\n1,\\n2\\n]\\n}\\n]", + "eval.tests.test_nativefuncs.test_manifest_json_indent[2-{\\n \"a\": 1,\\n \"b\": [\\n 1,\\n 2\\n ]\\n}\\n]", + "eval.tests.test_nativefuncs.test_manifest_json_indent[4-{\\n \"a\": 1,\\n \"b\": [\\n 1,\\n 2\\n ]\\n}\\n]", + "eval.tests.test_nativefuncs.test_manifest_json_top_level_array", + "eval.tests.test_nativefuncs.test_manifest_yaml_list", + "eval.tests.test_nativefuncs.test_manifest_yaml_mapping", + "eval.tests.test_nativefuncs.test_parse_helm_chart_arg_order_effect", + "eval.tests.test_nativefuncs.test_parse_helm_chart_bad_byte", + "eval.tests.test_nativefuncs.test_parse_helm_chart_empty_bytes", + "eval.tests.test_nativefuncs.test_parse_helm_chart_garbage_bytes", + "eval.tests.test_nativefuncs.test_parse_json_invalid[-unexpected end of JSON input]", + "eval.tests.test_nativefuncs.test_parse_json_invalid[[1,2,]-looking for beginning of value]", + "eval.tests.test_nativefuncs.test_parse_json_invalid[tru-in literal true]", + "eval.tests.test_nativefuncs.test_parse_json_invalid[{'single':1}-invalid character]", + "eval.tests.test_nativefuncs.test_parse_json_invalid[{not json}-looking for beginning of object key string]", + "eval.tests.test_nativefuncs.test_parse_json_unicode_escape", + "eval.tests.test_nativefuncs.test_parse_json_valid[42-42]", + "eval.tests.test_nativefuncs.test_parse_json_valid[[]-expected2]", + "eval.tests.test_nativefuncs.test_parse_json_valid[{\"a\":1,\"b\":[1,2,3]}-expected0]", + "eval.tests.test_nativefuncs.test_parse_json_valid[{\"nested\":{\"deep\":[{\"k\":\"v\"}]}}-expected4]", + "eval.tests.test_nativefuncs.test_parse_json_valid[{\"s\":\"x\",\"f\":1.5,\"n\":null,\"t\":true}-expected1]", + "eval.tests.test_nativefuncs.test_parse_yaml_empty_document", + "eval.tests.test_nativefuncs.test_parse_yaml_invalid[a: [1, 2\\n-error converting YAML to JSON]", + "eval.tests.test_nativefuncs.test_parse_yaml_invalid[{bad-error converting YAML to JSON]", + "eval.tests.test_nativefuncs.test_parse_yaml_scalar_document", + "eval.tests.test_nativefuncs.test_parse_yaml_typed_scalar_tag", + "eval.tests.test_nativefuncs.test_parse_yaml_valid[- 1\\n- 2\\n- 3\\n-expected2]", + "eval.tests.test_nativefuncs.test_parse_yaml_valid[a: 1\\nb: x\\n-expected0]", + "eval.tests.test_nativefuncs.test_parse_yaml_valid[x: hello\\n---\\nb: 2\\n-expected1]", + "eval.tests.test_nativefuncs.test_parse_yaml_valid[{}\\n-expected3]", + "eval.tests.test_nativefuncs.test_regex_match[$--True]", + "eval.tests.test_nativefuncs.test_regex_match[[a-z]+-12345-False]", + "eval.tests.test_nativefuncs.test_regex_match[[a-z]+-hello-True]", + "eval.tests.test_nativefuncs.test_regex_match[^foo-foobar-True]", + "eval.tests.test_nativefuncs.test_regex_match_anchored", + "eval.tests.test_nativefuncs.test_regex_match_empty_pattern", + "eval.tests.test_nativefuncs.test_regex_match_invalid_regex", + "eval.tests.test_nativefuncs.test_regex_subst[(\\\\w+)@(\\\\w+)-a@b-$2@$1-b@a]", + "eval.tests.test_nativefuncs.test_regex_subst[[0-9]-abc123-X-abcXXX]", + "eval.tests.test_nativefuncs.test_regex_subst[foo-foo foo-bar-bar bar]", + "eval.tests.test_nativefuncs.test_regex_subst[o-foooo-O-fOOOO]", + "eval.tests.test_nativefuncs.test_regex_subst_invalid_regex", + "eval.tests.test_nativefuncs.test_regex_subst_no_match_unchanged", + "eval.tests.test_nativefuncs.test_regex_subst_unmatched_group_literal", + "eval.tests.test_nativefuncs.test_resolve_image_custom_registry_port", + "eval.tests.test_nativefuncs.test_resolve_image_digest_preserved", + "eval.tests.test_nativefuncs.test_resolve_image_invalid_name", + "eval.tests.test_nativefuncs.test_resolve_image_latest_tag_default", + "eval.tests.test_nativefuncs.test_resolve_image_name_variants[busybox-docker.io/library/busybox:latest]", + "eval.tests.test_nativefuncs.test_resolve_image_name_variants[k8s.gcr.io/pause:3.2-k8s.gcr.io/pause:3.2]", + "eval.tests.test_nativefuncs.test_resolve_image_name_variants[quay.io/org/app:v2-quay.io/org/app:v2]", + "eval.tests.test_nativefuncs.test_resolve_image_name_variants[registry.example.com:5000/a/b@sha256:abababababababababababababababababababababababababababababababab-registry.example.com:5000/a/b@sha256:abababababababababababababababababababababababababababababababab]", + "eval.tests.test_nativefuncs.test_resolve_image_noop_default_registry", + "eval.tests.test_nativefuncs.test_validate_json_schema_array", + "eval.tests.test_nativefuncs.test_validate_json_schema_enum_pass", + "eval.tests.test_nativefuncs.test_validate_json_schema_enum_violation", + "eval.tests.test_nativefuncs.test_validate_json_schema_invalid_schema", + "eval.tests.test_nativefuncs.test_validate_json_schema_invalid_type", + "eval.tests.test_nativefuncs.test_validate_json_schema_nested_missing_required", + "eval.tests.test_nativefuncs.test_validate_json_schema_nested_ok", + "eval.tests.test_nativefuncs.test_validate_json_schema_null_value", + "eval.tests.test_nativefuncs.test_validate_json_schema_required_missing", + "eval.tests.test_nativefuncs.test_validate_json_schema_valid", + "eval.tests.test_nativefuncs.test_validate_json_schema_wrong_root_type", + "eval.tests.test_nativefuncs_helm.test_helm_capabilities_apiversion_absent_renders_null", + "eval.tests.test_nativefuncs_helm.test_helm_capabilities_apiversions_added", + "eval.tests.test_nativefuncs_helm.test_helm_capabilities_kubeversion_applied", + "eval.tests.test_nativefuncs_helm.test_helm_capabilities_major_minor", + "eval.tests.test_nativefuncs_helm.test_helm_chart_without_templates_yields_empty", + "eval.tests.test_nativefuncs_helm.test_helm_crd_parse_error_reported", + "eval.tests.test_nativefuncs_helm.test_helm_crd_rendered_under_crds_key", + "eval.tests.test_nativefuncs_helm.test_helm_default_capabilities_no_caps", + "eval.tests.test_nativefuncs_helm.test_helm_ignores_provided_helmversion", + "eval.tests.test_nativefuncs_helm.test_helm_large_chart_short_buffer", + "eval.tests.test_nativefuncs_helm.test_helm_multidoc_template", + "eval.tests.test_nativefuncs_helm.test_helm_notes_txt_skipped", + "eval.tests.test_nativefuncs_helm.test_helm_null_document_skipped", + "eval.tests.test_nativefuncs_helm.test_helm_present_namespace_not_overwritten", + "eval.tests.test_nativefuncs_helm.test_helm_render_configmap_namespace_filled", + "eval.tests.test_nativefuncs_helm.test_helm_render_error_reported", + "eval.tests.test_nativefuncs_helm.test_helm_render_template_values_and_release", + "eval.tests.test_nativefuncs_helm.test_helm_scalar_template_document", + "eval.tests.test_nativefuncs_helm.test_helm_subchart_dependency_rendered", + "eval.tests.test_nativefuncs_helm.test_helm_template_parse_error_reported", + "eval.tests.test_nativefuncs_helm.test_helm_values_merged_into_template", + "eval.tests.test_oci_importer.test_oci_bad_gzip_layer_fails", + "eval.tests.test_oci_importer.test_oci_bundle_cache_reuses_fetch_within_eval", + "eval.tests.test_oci_importer.test_oci_bundle_layer_fetch_error_propagates", + "eval.tests.test_oci_importer.test_oci_bundle_relative_import_inside_bundle", + "eval.tests.test_oci_importer.test_oci_config_fetch_error_propagates", + "eval.tests.test_oci_importer.test_oci_import_missing_file_is_not_found", + "eval.tests.test_oci_importer.test_oci_import_renders_bundle_file", + "eval.tests.test_oci_importer.test_oci_import_root_uses_entrypoint", + "eval.tests.test_oci_importer.test_oci_invalid_config_json_decode_fails", + "eval.tests.test_oci_importer.test_oci_manifest_fetch_error_propagates", + "eval.tests.test_oci_importer.test_oci_manifest_without_bundle_layer_fails", + "eval.tests.test_oci_importer.test_oci_multiple_bundle_files_rendered", + "eval.tests.test_oci_importer.test_oci_non_bundle_layer_is_skipped", + "eval.tests.test_oci_importer.test_oci_root_requires_nonempty_entrypoint", + "eval.tests.test_oci_importer.test_oci_root_without_path_normalizes_trailing_slash", + "eval.tests.test_oci_importer.test_oci_tar_directory_entry_is_skipped", + "eval.tests.test_oci_importer.test_oci_truncated_tar_fails", + "eval.tests.test_openapi_validate.test_validate_dangling_ref_rejected", + "eval.tests.test_openapi_validate.test_validate_empty_name_rejected", + "eval.tests.test_openapi_validate.test_validate_gvk_unknown_to_discovery_fails", + "eval.tests.test_openapi_validate.test_validate_gvk_without_schema_definition_skips", + "eval.tests.test_openapi_validate.test_validate_unknown_field_rejected", + "eval.tests.test_openapi_validate.test_validate_valid_object_passes", + "eval.tests.test_openapi_validate.test_validate_wrong_field_type_rejected", + "eval.tests.test_show_io.test_show_empty_file_runs_without_objects", + "eval.tests.test_show_io.test_show_export_custom_extension", + "eval.tests.test_show_io.test_show_export_custom_filename_format", + "eval.tests.test_show_io.test_show_export_dir_rejects_nonempty", + "eval.tests.test_show_io.test_show_export_dir_writes_file", + "eval.tests.test_show_io.test_show_json_each_object", + "eval.tests.test_show_io.test_show_missing_file", + "eval.tests.test_show_io.test_show_no_provenance_by_default", + "eval.tests.test_show_io.test_show_ns_less_object_renders", + "eval.tests.test_show_io.test_show_provenance_annotations", + "eval.tests.test_show_io.test_show_renders_various_kinds[configmap-ConfigMap]", + "eval.tests.test_show_io.test_show_renders_various_kinds[deployment-Deployment]", + "eval.tests.test_show_io.test_show_renders_various_kinds[service-Service]", + "eval.tests.test_show_io.test_show_unsupported_reorder", + "eval.tests.test_show_io.test_show_yaml_default", + "eval.tests.test_sort_reorder.test_show_reorder_server_configmap_fallback_tier", + "eval.tests.test_sort_reorder.test_show_reorder_server_crd_tier", + "eval.tests.test_sort_reorder.test_show_reorder_server_namespaces_then_names", + "eval.tests.test_sort_reorder.test_show_reorder_server_orders_dependencies_first", + "eval.tests.test_sort_reorder.test_show_reorder_server_same_tier_alphabetical", + "eval.tests.test_sort_reorder.test_show_reorder_server_webhook_tier", + "eval.tests.test_sort_reorder.test_show_without_reorder_preserves_input_order" + ] + }, + "generated_module_05": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_pack_oci.test_pack_auth_challenge_no_credentials", + "eval.tests.test_pack_oci.test_pack_docs_tar_ok", + "eval.tests.test_pack_oci.test_pack_docs_tgz_extension_accepted", + "eval.tests.test_pack_oci.test_pack_docs_wrong_extension_rejected[docs.json]", + "eval.tests.test_pack_oci.test_pack_docs_wrong_extension_rejected[notes.txt]", + "eval.tests.test_pack_oci.test_pack_docs_wrong_extension_rejected[readme]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[ ]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[/no-registry/path]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[:tag]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[\\t]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[]", + "eval.tests.test_pack_oci.test_pack_invalid_reference_reports_error[http://bad#]", + "eval.tests.test_pack_oci.test_pack_malformed_annotation_rejected[badanno]", + "eval.tests.test_pack_oci.test_pack_malformed_annotation_rejected[noequalsign]", + "eval.tests.test_pack_oci.test_pack_missing_root_file", + "eval.tests.test_pack_oci.test_pack_output_file_as_string_argument", + "eval.tests.test_pack_oci.test_pack_output_file_writes_bundled_tarball", + "eval.tests.test_pack_oci.test_pack_push_succeeds_against_registry[extra0]", + "eval.tests.test_pack_oci.test_pack_push_succeeds_against_registry[extra1]", + "eval.tests.test_pack_oci.test_pack_push_succeeds_against_registry[extra2]", + "eval.tests.test_pack_oci.test_pack_push_succeeds_against_registry[extra3]", + "eval.tests.test_pack_oci.test_pack_redirect_error_bubbles", + "eval.tests.test_pack_oci.test_pack_split_annotation_accepted[=novalue]", + "eval.tests.test_pack_oci.test_pack_split_annotation_accepted[key=val=extra]", + "eval.tests.test_pack_oci.test_pack_without_insecure_registry_uses_https", + "eval.tests.test_traceback_args.test_alpha_gating_blocks_command[pack-args1]", + "eval.tests.test_traceback_args.test_alpha_gating_blocks_command[traceback-args0]", + "eval.tests.test_traceback_args.test_missing_positional_arity[pack-2]", + "eval.tests.test_traceback_args.test_missing_positional_arity[traceback-1]", + "eval.tests.test_traceback_args.test_pack_help_lists_registry_flags", + "eval.tests.test_traceback_args.test_pack_no_alpha_refuses", + "eval.tests.test_traceback_args.test_too_many_positional_args[too_many0-1]", + "eval.tests.test_traceback_args.test_too_many_positional_args[too_many1-2]", + "eval.tests.test_traceback_args.test_traceback_help_lists_arguments_and_all_flag", + "eval.tests.test_traceback_args.test_traceback_missing_colon_argument", + "eval.tests.test_traceback_args.test_traceback_missing_file", + "eval.tests.test_traceback_args.test_traceback_non_numeric_line", + "eval.tests.test_traceback_args.test_unknown_traceback_flag_rejected", + "eval.tests.test_yamloc_errors.test_block_sequence_scalar_line_resolves", + "eval.tests.test_yamloc_errors.test_empty_file_unhandled_node", + "eval.tests.test_yamloc_errors.test_first_document_line_resolves_without_prov", + "eval.tests.test_yamloc_errors.test_leading_blank_lines_do_not_break_location", + "eval.tests.test_yamloc_errors.test_line_outside_tree_reports_not_found[-1]", + "eval.tests.test_yamloc_errors.test_line_outside_tree_reports_not_found[0]", + "eval.tests.test_yamloc_errors.test_line_outside_tree_reports_not_found[5]", + "eval.tests.test_yamloc_errors.test_line_outside_tree_reports_not_found[99999]", + "eval.tests.test_yamloc_errors.test_malformed_yaml_reports_yaml_error[a: [1,2\\n-did not find expected ',' or ']']", + "eval.tests.test_yamloc_errors.test_malformed_yaml_reports_yaml_error[a:\\n - { : unclosed\\n-did not find expected]", + "eval.tests.test_yamloc_errors.test_malformed_yaml_reports_yaml_error[{ a: b\\n-did not find expected ',' or '}']", + "eval.tests.test_yamloc_errors.test_quoted_mapping_key_resolves", + "eval.tests.test_yamloc_errors.test_scalar_root_yamloc_resolves_then_resource_unmarshal_fails", + "eval.tests.test_yamloc_errors.test_second_document_lines_are_invisible", + "eval.tests.test_yamloc_errors.test_value_scalar_line_resolves_nearest_key", + "eval.tests.test_yamloc_errors.test_whitespace_only_file_invalid_yaml", + "eval.tests.test_yamloc_errors.test_yaml_alias_anchors_resolve", + "eval.tests.test_yamloc_paths.test_provenance_path_deep_prefix", + "eval.tests.test_yamloc_paths.test_provenance_path_prefixes_yamloc_path", + "eval.tests.test_yamloc_paths.test_traceback_all_flag_preserves_located_path", + "eval.tests.test_yamloc_paths.test_traceback_prints_provenance_root_line", + "eval.tests.test_yamloc_paths.test_traceback_roots_cite_provenance_file[13-obj.jsonnet]", + "eval.tests.test_yamloc_paths.test_traceback_roots_cite_provenance_file[22-obj.jsonnet]", + "eval.tests.test_yamloc_paths.test_yamloc_last_content_line_scalar_array", + "eval.tests.test_yamloc_paths.test_yamloc_line_1_is_first_key", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[1-$.apiVersion]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[10-$.spec.template.spec.containers[0].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[11-$.spec.template.spec.containers[0].env]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[12-$.spec.template.spec.containers[0].env[0].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[13-$.spec.template.spec.containers[0].env[0].value]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[14-$.spec.template.spec.containers[0].env[1].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[15-$.spec.template.spec.containers[0].env[1].value]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[16-$.spec.template.spec.containers[1].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[17-$.spec.template.spec.containers[1].env]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[18-$.spec.template.spec.containers[1].env[0].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[19-$.spec.template.spec.containers[1].env[0].value]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[2-$.kind]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[20-$.spec.template.spec.containers[1].env[1].name]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[21-$.spec.template.spec.containers[1].env[1].value]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[22-$.spec.replicas]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[23-$.spec.someArrayOfScalars]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[24-$.spec.someArrayOfScalars[0]]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[3-$.spec]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[4-$.spec.selector]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[5-$.spec.selector.matchLabels]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[6-$.spec.selector.matchLabels.foo]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[7-$.spec.template]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[8-$.spec.template.spec]", + "eval.tests.test_yamloc_paths.test_yamloc_line_to_path[9-$.spec.template.spec.containers]", + "eval.tests.test_yamloc_paths.test_yamloc_partial_fixture_before_metadata", + "eval.tests.test_yamloc_paths.test_yamloc_scalar_array_second_element_short_circuits_to_0" + ] + }, + "generated_module_06": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_lib_assets_round5.test_embedded_lib_is_html_directory_listing", + "eval.tests.test_lib_assets_round5.test_embedded_lib_lasts_with_listing_anchor", + "eval.tests.test_lib_assets_round5.test_embedded_lib_lines_exact", + "eval.tests.test_lib_assets_round5.test_eval_expr_bare_super_syntax_error", + "eval.tests.test_lib_assets_round5.test_eval_expr_empty_is_noop", + "eval.tests.test_lib_assets_round5.test_eval_expr_keys_on_object_expr", + "eval.tests.test_lib_assets_round5.test_eval_expr_local_binding_reads_merged_scope", + "eval.tests.test_lib_assets_round5.test_eval_expr_nested_super_has_no_superclass", + "eval.tests.test_lib_assets_round5.test_eval_expr_self_at_root_is_whole_object", + "eval.tests.test_lib_assets_round5.test_eval_ext_code_file_missing_import_error", + "eval.tests.test_lib_assets_round5.test_eval_ext_str_empty_name_undefined_var", + "eval.tests.test_lib_assets_round5.test_eval_ext_str_file_newline_tab_preserved", + "eval.tests.test_lib_assets_round5.test_eval_ext_str_missing_equals_reports_missing_env", + "eval.tests.test_lib_assets_round5.test_eval_format_missing_value_then_no_filename", + "eval.tests.test_lib_assets_round5.test_eval_importbin_empty_file", + "eval.tests.test_lib_assets_round5.test_eval_importstr_relative_subdir", + "eval.tests.test_lib_assets_round5.test_eval_importstr_unicode_file_preserved", + "eval.tests.test_lib_assets_round5.test_eval_json_unicode_preserved", + "eval.tests.test_lib_assets_round5.test_eval_jsonnet_std_functions", + "eval.tests.test_lib_assets_round5.test_eval_tla_code_file_missing_import_error", + "eval.tests.test_lib_assets_round5.test_eval_tla_missing_value_flag_error", + "eval.tests.test_lib_assets_round5.test_eval_two_tla_code_args", + "eval.tests.test_lib_assets_round5.test_eval_yaml_empty_object", + "eval.tests.test_lib_assets_round5.test_eval_yaml_scalar_key_quoting", + "eval.tests.test_lib_assets_round5.test_version_clientgo_format_line", + "eval.tests.test_lib_assets_round5.test_version_jsonnet_semver_line", + "eval.tests.test_lib_ext_and_imports.test_eval_ext_code_file", + "eval.tests.test_lib_ext_and_imports.test_eval_ext_code_overrides_ext_str", + "eval.tests.test_lib_ext_and_imports.test_eval_ext_str_duplicate_last_wins", + "eval.tests.test_lib_ext_and_imports.test_eval_ext_str_file", + "eval.tests.test_lib_ext_and_imports.test_eval_importbin_local_lib_path", + "eval.tests.test_lib_ext_and_imports.test_eval_jpath_env_consulted_after_flag", + "eval.tests.test_lib_ext_and_imports.test_eval_jpath_flag_list_order_first_match", + "eval.tests.test_lib_ext_and_imports.test_eval_jpath_flag_list_order_second_matters", + "eval.tests.test_lib_ext_and_imports.test_eval_jpath_subdirectory_import", + "eval.tests.test_lib_ext_and_imports.test_eval_jurl_unreachable_remote", + "eval.tests.test_lib_imports_deep.test_eval_duplicate_tla_name_error", + "eval.tests.test_lib_imports_deep.test_eval_embedded_lib_bytes_exact", + "eval.tests.test_lib_imports_deep.test_eval_embedded_lib_importstr_content", + "eval.tests.test_lib_imports_deep.test_eval_expr_dollar_returns_whole_object", + "eval.tests.test_lib_imports_deep.test_eval_expr_function_missing_tla", + "eval.tests.test_lib_imports_deep.test_eval_expr_missing_filename", + "eval.tests.test_lib_imports_deep.test_eval_expr_number_invalid_for_keys", + "eval.tests.test_lib_imports_deep.test_eval_expr_override_replaces_object", + "eval.tests.test_lib_imports_deep.test_eval_expr_self_field_select", + "eval.tests.test_lib_imports_deep.test_eval_expr_super_field_access", + "eval.tests.test_lib_imports_deep.test_eval_ext_code_array_value", + "eval.tests.test_lib_imports_deep.test_eval_ext_str_empty_value", + "eval.tests.test_lib_imports_deep.test_eval_ext_str_special_chars_json", + "eval.tests.test_lib_imports_deep.test_eval_ext_str_unicode_preserved", + "eval.tests.test_lib_imports_deep.test_eval_import_chaining_relative", + "eval.tests.test_lib_imports_deep.test_eval_importbin_env_jpath", + "eval.tests.test_lib_imports_deep.test_eval_importbin_missing_error", + "eval.tests.test_lib_imports_deep.test_eval_relative_same_dir_import", + "eval.tests.test_lib_imports_deep.test_eval_relative_subdir_import", + "eval.tests.test_lib_imports_deep.test_eval_tla_code_file", + "eval.tests.test_lib_imports_deep.test_eval_tla_str_file", + "eval.tests.test_lib_imports_deep.test_eval_trace_writes_eval_file_path", + "eval.tests.test_lib_imports_deep.test_version_three_line_ordering", + "eval.tests.test_libsonnet_embed.test_eval_arithmetic", + "eval.tests.test_libsonnet_embed.test_eval_array_top_level", + "eval.tests.test_libsonnet_embed.test_eval_default_yaml_output", + "eval.tests.test_libsonnet_embed.test_eval_dimension_types_preserved", + "eval.tests.test_libsonnet_embed.test_eval_empty_file", + "eval.tests.test_libsonnet_embed.test_eval_ext_code", + "eval.tests.test_libsonnet_embed.test_eval_ext_str", + "eval.tests.test_libsonnet_embed.test_eval_ext_str_multiple", + "eval.tests.test_libsonnet_embed.test_eval_ext_var_missing", + "eval.tests.test_libsonnet_embed.test_eval_import_missing_consults_internal", + "eval.tests.test_libsonnet_embed.test_eval_import_via_jpath_env", + "eval.tests.test_libsonnet_embed.test_eval_import_via_jpath_flag", + "eval.tests.test_libsonnet_embed.test_eval_importbin_internal_libsonnet", + "eval.tests.test_libsonnet_embed.test_eval_internal_libsonnet_import_is_reachable", + "eval.tests.test_libsonnet_embed.test_eval_json_output", + "eval.tests.test_libsonnet_embed.test_eval_json_output_deep_nesting", + "eval.tests.test_libsonnet_embed.test_eval_null_top_level", + "eval.tests.test_libsonnet_embed.test_eval_requires_alpha", + "eval.tests.test_libsonnet_embed.test_eval_requires_filename", + "eval.tests.test_libsonnet_embed.test_eval_show_keys_json", + "eval.tests.test_libsonnet_embed.test_eval_show_keys_yaml", + "eval.tests.test_libsonnet_embed.test_eval_tla_code", + "eval.tests.test_libsonnet_embed.test_eval_tla_str", + "eval.tests.test_libsonnet_embed.test_eval_unsupported_format", + "eval.tests.test_version.test_root_help_lists_version", + "eval.tests.test_version.test_root_noargs_usage_lists_version", + "eval.tests.test_version.test_version_accepts_positional_rejection", + "eval.tests.test_version.test_version_clientgo_line", + "eval.tests.test_version.test_version_default_dev_build", + "eval.tests.test_version.test_version_exit_zero[plain]", + "eval.tests.test_version.test_version_exit_zero[with_alpha]", + "eval.tests.test_version.test_version_exit_zero[with_verbose]", + "eval.tests.test_version.test_version_exit_zero_with_all_global_bool_flags", + "eval.tests.test_version.test_version_help", + "eval.tests.test_version.test_version_help_short", + "eval.tests.test_version.test_version_jsonnet_line", + "eval.tests.test_version.test_version_kubecfg_line", + "eval.tests.test_version.test_version_output_has_exactly_three_lines", + "eval.tests.test_version.test_version_rejects_unknown_flag[hyphen]", + "eval.tests.test_version.test_version_rejects_unknown_flag[long]", + "eval.tests.test_version.test_version_rejects_unknown_flag[short]", + "eval.tests.test_version.test_version_subcommand_help_global_flags" + ] + } + }, + "commit": "64da3e7300577d84af03919d087c7bd89f319b8a", + "data_source": "synthetic_programgym", + "difficulty": "medium", + "difficulty_score": 3.9788535853927645, + "eval_clean_hashes": [ + "78332e621c5a5a4159e71a94e66c3bd6727aae6d2dec3e45d1cc35b1c30a4e33" + ], + "input_record": { + "commit": "64da3e7300577d84af03919d087c7bd89f319b8a", + "commits": 1384, + "contributors": 38, + "difficulty": "medium", + "difficulty_code_lines": 6145, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 6145, + "difficulty_runtime_deps": 154, + "difficulty_score": 3.9788535853927645, + "difficulty_test_code_lines": 4603, + "full_name": "kubecfg/kubecfg", + "github_stars": 257, + "input_joern_zip": "go_joern/kubecfg__kubecfg.zip", + "joern_status": true, + "joern_time": 20.70669186487794, + "language": "go", + "pb_match": [ + { + "pb_fullname": "segmentio/chamber", + "rank": 103, + "similarity": 0.5863134264945984 + }, + { + "pb_fullname": "sclevine/yj", + "rank": 102, + "similarity": 0.5374830961227417 + }, + { + "pb_fullname": "mikefarah/yq", + "rank": 212, + "similarity": 0.5583025217056274 + }, + { + "pb_fullname": "johnkerl/miller", + "rank": 631, + "similarity": 0.4725284278392792 + }, + { + "pb_fullname": "guumaster/hostctl", + "rank": 159, + "similarity": 0.49413809180259705 + }, + { + "pb_fullname": "gabotechs/dep-tree", + "rank": 296, + "similarity": 0.5380195379257202 + }, + { + "pb_fullname": "jesseduffield/lazygit", + "rank": 628, + "similarity": 0.5080455541610718 + }, + { + "pb_fullname": "FiloSottile/age", + "rank": 736, + "similarity": 0.45795226097106934 + }, + { + "pb_fullname": "boyter/scc", + "rank": 456, + "similarity": 0.5152003169059753 + }, + { + "pb_fullname": "rs/jplot", + "rank": 875, + "similarity": 0.4789322018623352 + }, + { + "pb_fullname": "multiprocessio/dsq", + "rank": 928, + "similarity": 0.4557749330997467 + }, + { + "pb_fullname": "skeema/skeema", + "rank": 277, + "similarity": 0.5350203514099121 + }, + { + "pb_fullname": "astaxie/bat", + "rank": 875, + "similarity": 0.5171034336090088 + }, + { + "pb_fullname": "noborus/trdsql", + "rank": 997, + "similarity": 0.47390469908714294 + }, + { + "pb_fullname": "cheat/cheat", + "rank": 784, + "similarity": 0.49109798669815063 + }, + { + "pb_fullname": "ariga/atlas", + "rank": 162, + "similarity": 0.5585853457450867 + }, + { + "pb_fullname": "tomnomnom/gron", + "rank": 801, + "similarity": 0.47674471139907837 + }, + { + "pb_fullname": "hairyhenderson/gomplate", + "rank": 632, + "similarity": 0.5183519124984741 + }, + { + "pb_fullname": "zk-org/zk", + "rank": 774, + "similarity": 0.5267379283905029 + } + ], + "repo_age": 4.71, + "repo_path": "go/kubecfg__kubecfg", + "source": "commit:64da3e7300577d84af03919d087c7bd89f319b8a", + "status": "done", + "url": "https://github.com/kubecfg/kubecfg" + }, + "instance_id": "kubecfg__kubecfg.64da3e7", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 7, + "branch_name": "generated_module_01", + "iteration_limit": 15, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 10, + "branch_name": "generated_module_02", + "iteration_limit": 15, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_03", + "iteration_limit": 15, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 14, + "branch_name": "generated_module_04", + "iteration_limit": 15, + "module_index": 4, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 2, + "branch_name": "generated_module_05", + "iteration_limit": 15, + "module_index": 5, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_06", + "iteration_limit": 15, + "module_index": 6, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "kubecfg/kubecfg" +} diff --git a/kubecfg--kubecfg.64da3e7/tests/test.sh b/kubecfg--kubecfg.64da3e7/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kubecfg--kubecfg.64da3e7/tests/workspace.tar.gz b/kubecfg--kubecfg.64da3e7/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6236041218ce3b2d84ecf8628ea5dc642d76f701 --- /dev/null +++ b/kubecfg--kubecfg.64da3e7/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0c4c3c9a89404241638271cd659714731810a00534009952f51f6985b25d281 +size 1610 diff --git a/kubernauts--tk8.87af949/environment/Dockerfile b/kubernauts--tk8.87af949/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6f371332b0892136e00733449b81644d11444adf --- /dev/null +++ b/kubernauts--tk8.87af949/environment/Dockerfile @@ -0,0 +1,58 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kubernauts--tk8.87af949/environment/download.sh b/kubernauts--tk8.87af949/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..3b47298babd8f299828540bf53a2396b5a63520c --- /dev/null +++ b/kubernauts--tk8.87af949/environment/download.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# +# download.sh -- ProgramGym download stage for kubernauts/tk8. +# +# TK8 (HEAD 87af949) is a legacy GOPATH-era Go project: it ships Gopkg.toml / +# Gopkg.lock (dep) as its lock metadata, but has no committed vendor/ tree and +# no go.mod. The pinned dep versions are reconstructed here as an inline go.mod +# written to a fixed literal directory (/tmp/pb-go-inline). Running +# `go mod download` with an explicit literal -modfile path (pointing at that +# inline-generated go.mod) populates the default module cache ( $HOME/go/pkg/mod ) +# which the offline build.sh later reuses. No repository file is read. +# +# This script is standalone by design: it must be valid in shell SOURCE mode +# (`source /source_ro/download.sh`), so it never reads repository files, never +# uses positional arguments, and never calls exit in normal control flow. + +set -u + +# Fixed literal directory and go.mod path. The -modfile flag must be a literal +# path, so every reference below is spelled out explicitly rather than through a +# variable. Writing into /tmp is safe because /source_ro is mounted read-only. +PB_GO_DIR="/tmp/pb-go-inline" + +mkdir -p "$PB_GO_DIR" || { + echo "download: could not create $PB_GO_DIR" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +} + +# --------------------------------------------------------------------------- +# Write the pinned go.mod inline. Versions correspond to the Gopkg.lock +# revisions resolved through the Go module proxy; tk8-provisioner-cattle-aws is +# pinned to the 2019-06-15 revision (just before 'Fix copy command' introduced +# common.CopyDir) so it compiles against tk8's own pkg/common. +# --------------------------------------------------------------------------- +cat > /tmp/pb-go-inline/go.mod <<'PBEOF' +module github.com/kubernauts/tk8 + +go 1.25.0 + +require ( + github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc + github.com/kubernauts/tk8-provisioner-aws v0.0.0-20181004111853-f9fcc3b18da8 + github.com/kubernauts/tk8-provisioner-azure v0.0.0-20181004113336-4fb96de260bc + github.com/kubernauts/tk8-provisioner-baremetal v0.0.0-20181004113739-fe44a20e6eaa + github.com/kubernauts/tk8-provisioner-cattle-aws v0.0.0-20190615122843-5ab424d5519f + github.com/kubernauts/tk8-provisioner-eks v0.0.0-20181004131018-31b8d7567de8 + github.com/kubernauts/tk8-provisioner-nutanix v0.0.0-20181004113327-ee759e7c0830 + github.com/kubernauts/tk8-provisioner-openstack v0.0.0-20181004113325-f29d34a5a87c + github.com/kubernauts/tk8-provisioner-rke v0.0.0-20190325110830-a966b1acdb16 + github.com/mitchellh/go-homedir v1.0.0 + github.com/spf13/cobra v1.2.1 + github.com/spf13/viper v1.8.1 +) + +require ( + github.com/CrowdSurge/banner v0.0.0-20140923200336-8c0e79dc5ff7 // indirect + github.com/aws/aws-sdk-go v1.15.47 // indirect + github.com/blang/semver v3.5.1+incompatible // indirect + github.com/dustinkirkland/golang-petname v0.0.0-20170921220637-d3c2ba80e75e // indirect + github.com/fsnotify/fsnotify v1.4.9 // indirect + github.com/go-ini/ini v1.38.3 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/inconshreveable/mousetrap v1.0.0 // indirect + github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 // indirect + github.com/magiconair/properties v1.8.5 // indirect + github.com/mitchellh/mapstructure v1.4.1 // indirect + github.com/pelletier/go-toml v1.9.3 // indirect + github.com/smartystreets/goconvey v1.8.1 // indirect + github.com/spf13/afero v1.6.0 // indirect + github.com/spf13/cast v1.3.1 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/stretchr/testify v1.12.1 // indirect + github.com/subosito/gotenv v1.2.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect + gopkg.in/ini.v1 v1.67.3 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) +PBEOF + +# --------------------------------------------------------------------------- +# Populate the module cache. Go discovers the module root from the working +# directory, so `cd` into the fixed directory that holds the generated go.mod, +# then run `go mod download` with an explicit literal -modfile path. +# --------------------------------------------------------------------------- +if ! command -v go; then + echo "download: no go toolchain found on PATH" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +fi + +cd /tmp/pb-go-inline || { + echo "download: could not cd into /tmp/pb-go-inline" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +} + +if ! go mod download -modfile=/tmp/pb-go-inline/go.mod; then + echo "download: go mod download failed" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +fi + +echo "download: tk8 Go module dependencies prefetched into the module cache." diff --git a/kubernauts--tk8.87af949/environment/executable b/kubernauts--tk8.87af949/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..97736c10c3bb28a8af264c8fc99335e09084b654 --- /dev/null +++ b/kubernauts--tk8.87af949/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4387ddc08b676ee751e82542039b8be1438440dc06c1cec0f7d1ce1ec054863 +size 16396754 diff --git a/kubernauts--tk8.87af949/environment/programgym-go.tar.gz b/kubernauts--tk8.87af949/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubernauts--tk8.87af949/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubernauts--tk8.87af949/environment/workspace.tar.gz b/kubernauts--tk8.87af949/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c94cb9e3016ee541448c3005743a663c79bbd2fe --- /dev/null +++ b/kubernauts--tk8.87af949/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bdd2d91acd0dcf7d4cdea7fd0cd7761607f76ba5b40b51e0b3c6e1093d1aad10 +size 27392 diff --git a/kubernauts--tk8.87af949/instruction.md b/kubernauts--tk8.87af949/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kubernauts--tk8.87af949/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kubernauts--tk8.87af949/solution/solve.sh b/kubernauts--tk8.87af949/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kubernauts--tk8.87af949/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kubernauts--tk8.87af949/task.toml b/kubernauts--tk8.87af949/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fd600891fd0a09bd5aadb66a183bf1ace2d44d6d --- /dev/null +++ b/kubernauts--tk8.87af949/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kubernauts--tk8.87af949" +description = "Synthetic ProgramGym cleanroom reconstruction task for kubernauts/tk8" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kubernauts__tk8.87af949" +repository = "kubernauts/tk8" +commit = "87af949152286847a553ebbbc82413e9ac230e4b" +language = "go" +difficulty = "easy" +difficulty_score = 1.2889196056617265 +test_branches = 4 +test_count = 331 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kubernauts--tk8.87af949/tests/Dockerfile b/kubernauts--tk8.87af949/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..bd5f12bacd787ef39a90a560bc0dec968dcdb06e --- /dev/null +++ b/kubernauts--tk8.87af949/tests/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_01.tar.gz b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..129ee30dfe0c86a6b13ef28a5d1bef1b01384089 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0bca2e2b97d86e84633c1bc72c281585b452208838cc054068bf5c0d9e76e9c0 +size 13382 diff --git a/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_02.tar.gz b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b8299cf753364cd395957776bf010622a17473bb --- /dev/null +++ b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f9c802a9cb784dafb8f5b6a19a155d4aaecea7ef2c280d0520ecdbe090fd606 +size 7603 diff --git a/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_03.tar.gz b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..a0259e7abbdef3232ade2abbe1aea18be76f7035 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b41da35db8403023d19cc945bfb0137b39f938199943cbc4600b89e2b46c9624 +size 12019 diff --git a/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_04.tar.gz b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..80797b573e80a2cecfd8f2c0f250412cf90bffa7 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6fcfd34e474d4cc5baec3b118e97f08e60f866235123a6aba7635035f847fc3c +size 18438 diff --git a/kubernauts--tk8.87af949/tests/download.sh b/kubernauts--tk8.87af949/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..3b47298babd8f299828540bf53a2396b5a63520c --- /dev/null +++ b/kubernauts--tk8.87af949/tests/download.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# +# download.sh -- ProgramGym download stage for kubernauts/tk8. +# +# TK8 (HEAD 87af949) is a legacy GOPATH-era Go project: it ships Gopkg.toml / +# Gopkg.lock (dep) as its lock metadata, but has no committed vendor/ tree and +# no go.mod. The pinned dep versions are reconstructed here as an inline go.mod +# written to a fixed literal directory (/tmp/pb-go-inline). Running +# `go mod download` with an explicit literal -modfile path (pointing at that +# inline-generated go.mod) populates the default module cache ( $HOME/go/pkg/mod ) +# which the offline build.sh later reuses. No repository file is read. +# +# This script is standalone by design: it must be valid in shell SOURCE mode +# (`source /source_ro/download.sh`), so it never reads repository files, never +# uses positional arguments, and never calls exit in normal control flow. + +set -u + +# Fixed literal directory and go.mod path. The -modfile flag must be a literal +# path, so every reference below is spelled out explicitly rather than through a +# variable. Writing into /tmp is safe because /source_ro is mounted read-only. +PB_GO_DIR="/tmp/pb-go-inline" + +mkdir -p "$PB_GO_DIR" || { + echo "download: could not create $PB_GO_DIR" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +} + +# --------------------------------------------------------------------------- +# Write the pinned go.mod inline. Versions correspond to the Gopkg.lock +# revisions resolved through the Go module proxy; tk8-provisioner-cattle-aws is +# pinned to the 2019-06-15 revision (just before 'Fix copy command' introduced +# common.CopyDir) so it compiles against tk8's own pkg/common. +# --------------------------------------------------------------------------- +cat > /tmp/pb-go-inline/go.mod <<'PBEOF' +module github.com/kubernauts/tk8 + +go 1.25.0 + +require ( + github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc + github.com/kubernauts/tk8-provisioner-aws v0.0.0-20181004111853-f9fcc3b18da8 + github.com/kubernauts/tk8-provisioner-azure v0.0.0-20181004113336-4fb96de260bc + github.com/kubernauts/tk8-provisioner-baremetal v0.0.0-20181004113739-fe44a20e6eaa + github.com/kubernauts/tk8-provisioner-cattle-aws v0.0.0-20190615122843-5ab424d5519f + github.com/kubernauts/tk8-provisioner-eks v0.0.0-20181004131018-31b8d7567de8 + github.com/kubernauts/tk8-provisioner-nutanix v0.0.0-20181004113327-ee759e7c0830 + github.com/kubernauts/tk8-provisioner-openstack v0.0.0-20181004113325-f29d34a5a87c + github.com/kubernauts/tk8-provisioner-rke v0.0.0-20190325110830-a966b1acdb16 + github.com/mitchellh/go-homedir v1.0.0 + github.com/spf13/cobra v1.2.1 + github.com/spf13/viper v1.8.1 +) + +require ( + github.com/CrowdSurge/banner v0.0.0-20140923200336-8c0e79dc5ff7 // indirect + github.com/aws/aws-sdk-go v1.15.47 // indirect + github.com/blang/semver v3.5.1+incompatible // indirect + github.com/dustinkirkland/golang-petname v0.0.0-20170921220637-d3c2ba80e75e // indirect + github.com/fsnotify/fsnotify v1.4.9 // indirect + github.com/go-ini/ini v1.38.3 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/inconshreveable/mousetrap v1.0.0 // indirect + github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 // indirect + github.com/magiconair/properties v1.8.5 // indirect + github.com/mitchellh/mapstructure v1.4.1 // indirect + github.com/pelletier/go-toml v1.9.3 // indirect + github.com/smartystreets/goconvey v1.8.1 // indirect + github.com/spf13/afero v1.6.0 // indirect + github.com/spf13/cast v1.3.1 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/stretchr/testify v1.12.1 // indirect + github.com/subosito/gotenv v1.2.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect + gopkg.in/ini.v1 v1.67.3 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) +PBEOF + +# --------------------------------------------------------------------------- +# Populate the module cache. Go discovers the module root from the working +# directory, so `cd` into the fixed directory that holds the generated go.mod, +# then run `go mod download` with an explicit literal -modfile path. +# --------------------------------------------------------------------------- +if ! command -v go; then + echo "download: no go toolchain found on PATH" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +fi + +cd /tmp/pb-go-inline || { + echo "download: could not cd into /tmp/pb-go-inline" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +} + +if ! go mod download -modfile=/tmp/pb-go-inline/go.mod; then + echo "download: go mod download failed" + if [ "${BASH_SOURCE[0]}" != "$0" ]; then return 1; else exit 1; fi +fi + +echo "download: tk8 Go module dependencies prefetched into the module cache." diff --git a/kubernauts--tk8.87af949/tests/executable b/kubernauts--tk8.87af949/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..97736c10c3bb28a8af264c8fc99335e09084b654 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4387ddc08b676ee751e82542039b8be1438440dc06c1cec0f7d1ce1ec054863 +size 16396754 diff --git a/kubernauts--tk8.87af949/tests/programgym-go.tar.gz b/kubernauts--tk8.87af949/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubernauts--tk8.87af949/tests/programgym_evaluator.py b/kubernauts--tk8.87af949/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kubernauts--tk8.87af949/tests/programgym_task.json b/kubernauts--tk8.87af949/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..35405bde7c41cb8a09af2168a2d5d49bda815d2e --- /dev/null +++ b/kubernauts--tk8.87af949/tests/programgym_task.json @@ -0,0 +1,437 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_addon.test_addon_create_accepts_extra_positional_args", + "eval.tests.test_addon.test_addon_create_help", + "eval.tests.test_addon.test_addon_create_help_and_idempotency_distinct", + "eval.tests.test_addon.test_addon_create_when_local_exists_is_idempotent", + "eval.tests.test_addon.test_addon_destroy_accepts_extra_positional_args", + "eval.tests.test_addon.test_addon_destroy_accepts_kubeconfig_flag_and_completes", + "eval.tests.test_addon.test_addon_destroy_blank_addon_completes_with_no_scripts", + "eval.tests.test_addon.test_addon_destroy_failing_destroy_sh_aborts", + "eval.tests.test_addon.test_addon_destroy_failing_main_sh_aborts_removal", + "eval.tests.test_addon.test_addon_destroy_help_documents_scope_flag", + "eval.tests.test_addon.test_addon_destroy_kubeconfig_drives_manifest_delete_and_completes", + "eval.tests.test_addon.test_addon_destroy_local_with_main_sh", + "eval.tests.test_addon.test_addon_destroy_main_yaml_fallback", + "eval.tests.test_addon.test_addon_destroy_prefixed_runs_destroy_sh", + "eval.tests.test_addon.test_addon_destroy_prefixed_strips_name_in_manifest_delete", + "eval.tests.test_addon.test_addon_destroy_runs_destroy_sh_then_removes_manifest", + "eval.tests.test_addon.test_addon_destroy_scope_flows_to_destroy_sh", + "eval.tests.test_addon.test_addon_destroy_with_destroy_sh_golden", + "eval.tests.test_addon.test_addon_destroy_with_manifest_deletes_it", + "eval.tests.test_addon.test_addon_get_create_accept_kubeconfig_flag[argv0-Found g1 local.]", + "eval.tests.test_addon.test_addon_get_create_accept_kubeconfig_flag[argv1-Addon c1 already exist]", + "eval.tests.test_addon.test_addon_get_finds_local_addon", + "eval.tests.test_addon.test_addon_get_finds_local_addon_with_prefix", + "eval.tests.test_addon.test_addon_get_help", + "eval.tests.test_addon.test_addon_get_rejects_scope_flag", + "eval.tests.test_addon.test_addon_get_uses_trailing_path_component_as_name", + "eval.tests.test_addon.test_addon_help_lists_subcommands", + "eval.tests.test_addon.test_addon_install_accepts_extra_positional_args", + "eval.tests.test_addon.test_addon_install_accepts_kubeconfig_flag_and_completes", + "eval.tests.test_addon.test_addon_install_failing_main_sh_aborts", + "eval.tests.test_addon.test_addon_install_help_documents_scope_flag", + "eval.tests.test_addon.test_addon_install_local_runs_main_sh", + "eval.tests.test_addon.test_addon_install_main_yaml_fallback", + "eval.tests.test_addon.test_addon_install_prefers_main_yml_manifest", + "eval.tests.test_addon.test_addon_install_prefixed_does_not_strip_name", + "eval.tests.test_addon.test_addon_install_scope_and_manifest_apply", + "eval.tests.test_addon.test_addon_install_scope_flows_to_main_sh", + "eval.tests.test_addon.test_addon_install_scope_short_alias", + "eval.tests.test_addon.test_addon_install_with_no_manifest_reports_stat_error", + "eval.tests.test_addon.test_addon_no_args_rejected", + "eval.tests.test_addon.test_addon_no_args_rejected_by_cobra_not_parent_run", + "eval.tests.test_addon.test_addon_parent_help_shows_inherited_kubeconfig_flag", + "eval.tests.test_addon.test_addon_parent_runs_for_non_subcommand", + "eval.tests.test_addon.test_addon_unknown_verb_lists_commands", + "eval.tests.test_addon.test_addon_verb_requires_an_argument[create]", + "eval.tests.test_addon.test_addon_verb_requires_an_argument[destroy]", + "eval.tests.test_addon.test_addon_verb_requires_an_argument[get]", + "eval.tests.test_addon.test_addon_verb_requires_an_argument[install]", + "eval.tests.test_cluster.test_cluster_help_flag", + "eval.tests.test_cluster.test_cluster_no_args_prints_help", + "eval.tests.test_cluster.test_cluster_no_args_shows_provisioner_verbs", + "eval.tests.test_cluster.test_cluster_unknown_subcommand_rejected[bogus]", + "eval.tests.test_cluster.test_cluster_unknown_subcommand_rejected[help]", + "eval.tests.test_cluster.test_cluster_unknown_subcommand_rejected[init]", + "eval.tests.test_cluster.test_cluster_unknown_subcommand_rejected[nope]", + "eval.tests.test_completion.test_completion_bash_accepts_extra_positional_args", + "eval.tests.test_completion.test_completion_bash_creates_tk8_sh", + "eval.tests.test_completion.test_completion_bash_help", + "eval.tests.test_completion.test_completion_bash_overwrites_existing_file", + "eval.tests.test_completion.test_completion_help_flag", + "eval.tests.test_completion.test_completion_no_args_prints_help", + "eval.tests.test_completion.test_completion_positional_silently_succeeds[help]", + "eval.tests.test_completion.test_completion_positional_silently_succeeds[nonsense]", + "eval.tests.test_completion.test_completion_zsh_accepts_extra_positional_args", + "eval.tests.test_completion.test_completion_zsh_creates_plugin_file", + "eval.tests.test_completion.test_completion_zsh_help", + "eval.tests.test_completion.test_completion_zsh_overwrites_existing_file", + "eval.tests.test_provisioner.test_every_known_provisioner_advertised_in_each_verb", + "eval.tests.test_provisioner.test_every_known_provisioner_advertised_in_install_use", + "eval.tests.test_provisioner.test_install_error_stderr_has_cobra_diagnostic", + "eval.tests.test_provisioner.test_install_help_shows_ionly_and_name_flags", + "eval.tests.test_provisioner.test_other_verbs_document_name_flag[destroy]", + "eval.tests.test_provisioner.test_other_verbs_document_name_flag[remove]", + "eval.tests.test_provisioner.test_other_verbs_document_name_flag[reset]", + "eval.tests.test_provisioner.test_other_verbs_document_name_flag[scale]", + "eval.tests.test_provisioner.test_other_verbs_document_name_flag[upgrade]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[destroy]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[install]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[remove]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[reset]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[scale]", + "eval.tests.test_provisioner.test_provisioner_verb_requires_an_argument[upgrade]", + "eval.tests.test_provisioner.test_scale_help_targets_scaling", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[destroy]", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[install]", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[remove]", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[reset]", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[scale]", + "eval.tests.test_provisioner.test_unsupported_provisioner_rejected[upgrade]", + "eval.tests.test_provisioner.test_upgrade_help_targets_aws_terraforming", + "eval.tests.test_root.test_each_subcommand_supports_help_flag", + "eval.tests.test_root.test_help_addon_subcommand_routes_to_addon_help", + "eval.tests.test_root.test_help_subcommand_prints_root_help", + "eval.tests.test_root.test_help_version_subcommand", + "eval.tests.test_root.test_long_help_flag_prints_root_help", + "eval.tests.test_root.test_no_args_prints_root_help", + "eval.tests.test_root.test_short_help_flag_prints_root_help", + "eval.tests.test_root.test_unknown_command_errors", + "eval.tests.test_root.test_unknown_flag_errors", + "eval.tests.test_root.test_version_help", + "eval.tests.test_root.test_version_ignores_extra_positional_args", + "eval.tests.test_root.test_version_prints_build_version" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_addon_cli.TestArgumentValidation.test_addon_create_requires_name_arg", + "eval.tests.test_addon_cli.TestArgumentValidation.test_addon_destroy_requires_name_arg", + "eval.tests.test_addon_cli.TestArgumentValidation.test_addon_get_requires_name_arg", + "eval.tests.test_addon_cli.TestArgumentValidation.test_addon_install_requires_name_arg", + "eval.tests.test_addon_cli.TestArgumentValidation.test_addon_requires_at_least_one_arg", + "eval.tests.test_addon_cli.TestConfigPrerequisite.test_present_config_allows_addon_dispatch", + "eval.tests.test_addon_cli.TestHelp.test_addon_create_help", + "eval.tests.test_addon_cli.TestHelp.test_addon_destroy_help", + "eval.tests.test_addon_cli.TestHelp.test_addon_get_help_documents_url_usage", + "eval.tests.test_addon_cli.TestHelp.test_addon_help_lists_subcommands", + "eval.tests.test_addon_cli.TestHelp.test_addon_help_short_flag", + "eval.tests.test_addon_cli.TestHelp.test_addon_install_help_documents_scope", + "eval.tests.test_addon_cli.TestRootHelp.test_root_help_lists_addon_command", + "eval.tests.test_addon_create.TestCreate.test_create_does_not_report_already_exist_for_new_name", + "eval.tests.test_addon_create.TestCreate.test_create_existing_addon_reports_already_exists", + "eval.tests.test_addon_create.TestCreate.test_create_new_addon_creates_addons_parent_dir", + "eval.tests.test_addon_destroy.TestDestroyErrors.test_destroy_failing_destroy_sh_aborts", + "eval.tests.test_addon_destroy.TestDestroyErrors.test_destroy_main_sh_fallback_failure_aborts", + "eval.tests.test_addon_destroy.TestDestroyErrors.test_destroy_manifest_present_with_yml", + "eval.tests.test_addon_destroy.TestDestroyPrefixStripping.test_destroy_tk8_addon_prefix_stripped_in_messages", + "eval.tests.test_addon_destroy.TestDestroySuccess.test_destroy_fallback_to_main_sh_clean_manifest", + "eval.tests.test_addon_destroy.TestDestroySuccess.test_destroy_scope_flag_forwarded_to_destroy_sh", + "eval.tests.test_addon_destroy.TestDestroySuccess.test_destroy_with_destroy_sh_main_yml", + "eval.tests.test_addon_destroy.TestDestroySuccess.test_destroy_without_scripts_but_main_yaml", + "eval.tests.test_addon_get.TestGetFallback.test_get_http_url_uses_external_path_branch", + "eval.tests.test_addon_get.TestGetFallback.test_get_https_extracts_last_segment_for_status", + "eval.tests.test_addon_get.TestGetFallback.test_get_https_url_uses_external_path_branch", + "eval.tests.test_addon_get.TestGetFallback.test_get_mixed_scheme_not_url_falls_to_space", + "eval.tests.test_addon_get.TestGetFallback.test_get_plain_not_found_tries_kubernauts_space", + "eval.tests.test_addon_get.TestGetLocalPresent.test_get_local_path_present_does_not_touch_network", + "eval.tests.test_addon_get.TestGetLocalPresent.test_get_plain_name_resolves_local", + "eval.tests.test_addon_get.TestGetLocalPresent.test_get_prefixed_name_queried_directly", + "eval.tests.test_addon_get.TestGetLocalPresent.test_get_slash_path_uses_last_segment_for_local_lookup", + "eval.tests.test_addon_get.TestGetLocalPresent.test_get_tk8_addon_prefixed_name_resolves_local_second_path", + "eval.tests.test_addon_get.TestGetNameExtraction.test_get_leading_slash_strip", + "eval.tests.test_addon_get.TestGetNameExtraction.test_get_nested_path_extracts_final_component", + "eval.tests.test_addon_get.TestGetNameExtraction.test_get_trailing_slash_yields_empty_name_then_space_lookup", + "eval.tests.test_addon_install.TestInstallEdgeCases.test_install_kubeconfig_equals_form", + "eval.tests.test_addon_install.TestInstallEdgeCases.test_install_kubeconfig_persistent_flag_accepted", + "eval.tests.test_addon_install.TestInstallEdgeCases.test_install_no_manifest_prints_stat_error", + "eval.tests.test_addon_install.TestInstallEdgeCases.test_install_prefixed_local_name_reports_prefixed_completion", + "eval.tests.test_addon_install.TestInstallSuccess.test_install_local_main_yaml_fallback", + "eval.tests.test_addon_install.TestInstallSuccess.test_install_local_main_yml_only", + "eval.tests.test_addon_install.TestInstallSuccess.test_install_prefers_main_yml_over_main_yaml", + "eval.tests.test_addon_install.TestInstallWithMainSh.test_install_main_sh_failure_aborts_before_apply", + "eval.tests.test_addon_install.TestInstallWithMainSh.test_install_main_sh_side_effect_file_created", + "eval.tests.test_addon_install.TestInstallWithMainSh.test_install_runs_main_sh_then_applies", + "eval.tests.test_addon_install.TestInstallWithMainSh.test_install_scope_flag_forwarded_to_main_sh", + "eval.tests.test_addon_install.TestInstallWithMainSh.test_install_scope_flag_long_form" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_provisioner_arg_and_help.test_cluster_help_lists_all_provisioner_operations", + "eval.tests.test_provisioner_arg_and_help.test_destroy_unsupported_provisioner_rejected", + "eval.tests.test_provisioner_arg_and_help.test_install_help_documents_ionly_flag", + "eval.tests.test_provisioner_arg_and_help.test_install_requires_at_least_one_arg", + "eval.tests.test_provisioner_arg_and_help.test_install_unsupported_provisioner_rejected", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[destroy-destroy the infrastructure which was created with the install command---name string]", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[install-provide the infrastructure which is needed to install and run kubernetes--i, --ionly]", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[remove-scale down the existing infrastructure and the kubernetes cluster to the desired strength---name string]", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[reset-reset the existing infrastructure and will remove kubernetes---name string]", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[scale-scale up the existing infrastructure and the kubernetes cluster to the desired strength---name string]", + "eval.tests.test_provisioner_arg_and_help.test_operation_help_shows_description_and_flags[upgrade-Create, delete and show current status of the deployment that is running on AWS---name string]", + "eval.tests.test_provisioner_arg_and_help.test_scale_requires_at_least_one_arg", + "eval.tests.test_provisioner_execute_terraform.test_execute_terraform_dependency_gate_missing_terraform[destroy-starting terraform destroy]", + "eval.tests.test_provisioner_execute_terraform.test_execute_terraform_dependency_gate_missing_terraform[upgrade-Starting Upgrade of the existing cluster]", + "eval.tests.test_provisioner_execute_terraform.test_execute_terraform_gate_is_deterministic_across_cwd", + "eval.tests.test_provisioner_execute_terraform.test_rke_destroy_reports_terraform_missing_before_running", + "eval.tests.test_provisioner_execute_terraform.test_rke_upgrade_reports_terraform_missing_before_running", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_apply_plan_error_exits_nonzero", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_dependency_gate_bypassed_with_real_terraform", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_exit_code_matches_plan_status[-0-CMD:destroy -var-file=credentials.tfvars -force\\n]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_exit_code_matches_plan_status[Error: Error applying plan-1-CMD:destroy -var-file=credentials.tfvars -force\\nError: Error applying plan\\nTerraform could not setup the infrastructure\\n]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_exit_code_matches_plan_status[module.x.destroying...-0-CMD:destroy -var-file=credentials.tfvars -force\\nmodule.x.destroying...\\n]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_ignores_nonzero_terraform_exit_with_clean_stream[127]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_ignores_nonzero_terraform_exit_with_clean_stream[1]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_ignores_nonzero_terraform_exit_with_clean_stream[2]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_ignores_nonzero_terraform_exit_with_clean_stream[3]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_ignores_nonzero_terraform_exit_with_clean_stream[5]", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_interleaves_stdout_and_stderr_lines", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_plan_error_marker_on_stderr_still_aborts", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_plan_error_precedes_nonzero_child_exit", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_runs_terraform_destroy_with_force", + "eval.tests.test_provisioner_execute_terraform_deep.test_destroy_rke_streams_multiline_terraform_output", + "eval.tests.test_provisioner_execute_terraform_deep.test_execute_terraform_start_error_when_workdir_missing", + "eval.tests.test_provisioner_execute_terraform_deep.test_execute_terraform_start_error_with_named_workdir", + "eval.tests.test_provisioner_execute_terraform_deep.test_execute_terraform_success_vs_missing_dir_are_distinct", + "eval.tests.test_provisioner_execute_terraform_deep.test_execute_terraform_uses_name_in_terraform_workdir", + "eval.tests.test_provisioner_execute_terraform_deep.test_no_blackbox_operation_invokes_terraform_init", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_apply_plan_error_aborts_with_message", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_error_plan_mid_stream_keeps_prior_lines", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_ignores_nonzero_terraform_exit_with_clean_stream[1]", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_ignores_nonzero_terraform_exit_with_clean_stream[9]", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_merges_terraform_stderr_into_stdout", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_plan_error_marker_on_stderr_keeps_prior_stdout", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_runs_terraform_apply_with_auto_approve", + "eval.tests.test_provisioner_execute_terraform_deep.test_upgrade_rke_streams_each_terraform_output_line", + "eval.tests.test_provisioner_notimplemented.test_install_with_ionly_flag_still_reaches_not_implemented", + "eval.tests.test_provisioner_notimplemented.test_install_with_name_flag_reaches_not_implemented", + "eval.tests.test_provisioner_notimplemented.test_install_with_short_ionly_flag_reaches_not_implemented", + "eval.tests.test_provisioner_notimplemented.test_ionly_flag_skips_placeholder_setup", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[aws-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[aws-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-destroy]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-install]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[azure-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[baremetal-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[baremetal-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[baremetal-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[baremetal-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[cattle-aws-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[cattle-aws-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[cattle-aws-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[eks-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[eks-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[eks-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[eks-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-destroy]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-install]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[nutanix-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[openstack-remove]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[openstack-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[openstack-scale]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[openstack-upgrade]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[rke-reset]", + "eval.tests.test_provisioner_notimplemented.test_provisioner_operation_returns_not_implemented[rke-scale]" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_addon.test_addon_create_refuses_existing_folder", + "eval.tests.test_addon.test_addon_destroy_falls_back_to_main_script", + "eval.tests.test_addon.test_addon_destroy_runs_destroy_script", + "eval.tests.test_addon.test_addon_get_detects_local_addon_without_prefix", + "eval.tests.test_addon.test_addon_get_existing_local_reports_found", + "eval.tests.test_addon.test_addon_get_on_dir_with_slash_extracts_basename", + "eval.tests.test_addon.test_addon_install_does_not_clone_when_addon_present", + "eval.tests.test_addon.test_addon_install_reports_missing_main_manifest", + "eval.tests.test_addon.test_addon_install_runs_local_main_script", + "eval.tests.test_completion.test_completion_bash_and_zsh_write_distinct_payload_files", + "eval.tests.test_completion.test_completion_bash_contains_tk8_command_metadata", + "eval.tests.test_completion.test_completion_bash_contains_version_subcommand_reference", + "eval.tests.test_completion.test_completion_bash_creates_tk8_sh_file", + "eval.tests.test_completion.test_completion_bash_exact_success_message", + "eval.tests.test_completion.test_completion_bash_file_begins_with_bash_completion_marker", + "eval.tests.test_completion.test_completion_bash_file_has_restricted_mode_0600", + "eval.tests.test_completion.test_completion_bash_idempotent_overwrite", + "eval.tests.test_completion.test_completion_parent_help_lists_bash_and_zsh", + "eval.tests.test_completion.test_completion_zsh_creates_plugin_file", + "eval.tests.test_completion.test_completion_zsh_exact_success_message", + "eval.tests.test_completion.test_completion_zsh_file_begins_with_complete_function", + "eval.tests.test_completion.test_completion_zsh_file_ends_with_compdef_registration", + "eval.tests.test_completion.test_completion_zsh_file_has_restricted_mode_0600", + "eval.tests.test_completion_error.test_completion_bash_and_zsh_open_collisions_are_distinct", + "eval.tests.test_completion_error.test_completion_bash_open_error_leaves_stdout_empty", + "eval.tests.test_completion_error.test_completion_open_error_diagnostic_names_the_file[bash-tk8.sh]", + "eval.tests.test_completion_error.test_completion_open_error_diagnostic_names_the_file[zsh-tk8.plugin.zsh]", + "eval.tests.test_completion_error.test_completion_open_error_does_not_write_script_content", + "eval.tests.test_completion_error.test_completion_script_open_collision_exits_one[bash-tk8.sh]", + "eval.tests.test_completion_error.test_completion_script_open_collision_exits_one[zsh-tk8.plugin.zsh]", + "eval.tests.test_completion_error.test_completion_zsh_open_error_leaves_stdout_empty", + "eval.tests.test_completion_streams.test_completion_bash_file_then_directory_switches_to_error_path", + "eval.tests.test_completion_streams.test_completion_bash_fully_replaces_preexisting_smaller_file", + "eval.tests.test_completion_streams.test_completion_bash_help_lists_usage_and_description", + "eval.tests.test_completion_streams.test_completion_bash_keeps_trailing_stale_bytes_when_preexisting_large", + "eval.tests.test_completion_streams.test_completion_bash_large_preexisting_script_mode_stays_unchanged", + "eval.tests.test_completion_streams.test_completion_bash_script_is_syntactically_valid_bash", + "eval.tests.test_completion_streams.test_completion_bash_script_uses_unix_lf_line_endings", + "eval.tests.test_completion_streams.test_completion_bash_success_keeps_stderr_empty", + "eval.tests.test_completion_streams.test_completion_without_args_shows_parent_help", + "eval.tests.test_completion_streams.test_completion_zsh_help_lists_usage_and_description", + "eval.tests.test_completion_streams.test_completion_zsh_plugin_registers_compdef_and_tool_complete", + "eval.tests.test_completion_streams.test_completion_zsh_success_keeps_stderr_empty", + "eval.tests.test_completion_symlink.test_completion_bash_dangling_symlink_recovers_after_parent_created", + "eval.tests.test_completion_symlink.test_completion_bash_fully_replaces_smaller_symlink_target", + "eval.tests.test_completion_symlink.test_completion_bash_symlink_write_changes_only_target_not_sibling", + "eval.tests.test_completion_symlink.test_completion_bash_writes_through_symlink_to_large_target", + "eval.tests.test_completion_symlink.test_completion_zsh_dangling_symlink_fails_open_with_no_such_file", + "eval.tests.test_config.test_missing_config_emits_startup_diagnostic_then_waits", + "eval.tests.test_config.test_missing_config_first_line_is_blank", + "eval.tests.test_config.test_seeded_config_does_not_block_on_input", + "eval.tests.test_config.test_seeded_config_suppresses_startup_prompt[argv0]", + "eval.tests.test_config.test_seeded_config_suppresses_startup_prompt[argv1]", + "eval.tests.test_config.test_seeded_config_suppresses_startup_prompt[argv2]", + "eval.tests.test_dependency_check.test_dependency_failure_aborts_before_any_stub_output", + "eval.tests.test_dependency_check.test_dependency_route_requires_preseeded_provisioner_dir[cattle-aws-install-kubectl not found, kindly check]", + "eval.tests.test_dependency_check.test_dependency_route_requires_preseeded_provisioner_dir[openstack-install-Terraform command not found, kindly check]", + "eval.tests.test_dependency_check.test_dependency_route_requires_preseeded_provisioner_dir[rke-install-kubectl not found, kindly check]", + "eval.tests.test_dependency_check.test_destroy_openstack_also_checks_terraform_dependency", + "eval.tests.test_dependency_check.test_install_missing_external_binary_dependency[cattle-aws-install-kubectl not found, kindly check]", + "eval.tests.test_dependency_check.test_install_missing_external_binary_dependency[openstack-install-Terraform command not found, kindly check]", + "eval.tests.test_dependency_check.test_install_missing_external_binary_dependency[rke-install-kubectl not found, kindly check]", + "eval.tests.test_dependency_check.test_install_openstack_diagnostic_is_on_stderr_not_stdout", + "eval.tests.test_dependency_check.test_rke_and_cattle_aws_share_kubectl_dependency_diagnostic", + "eval.tests.test_help_args.test_addon_help_lists_subcommands", + "eval.tests.test_help_args.test_addon_without_subcommand_is_rejected", + "eval.tests.test_help_args.test_bare_invocation_shows_root_help", + "eval.tests.test_help_args.test_cluster_install_help_lists_provisioner_choices", + "eval.tests.test_help_args.test_cluster_install_missing_arg_is_rejected", + "eval.tests.test_help_args.test_cluster_install_unsupported_provisioner_message", + "eval.tests.test_help_args.test_cluster_with_no_subcommand_shows_cluster_help", + "eval.tests.test_help_args.test_h_flag_shows_root_help", + "eval.tests.test_help_args.test_help_flag_shows_root_help", + "eval.tests.test_help_args.test_help_subcommand_shows_root_help", + "eval.tests.test_help_args.test_unknown_root_command_exits_nonzero", + "eval.tests.test_help_args.test_unknown_subcommand_exits_nonzero", + "eval.tests.test_provisioner.test_clone_git_creates_missing_parent_provisioner_dir", + "eval.tests.test_provisioner.test_each_provisioner_uses_own_provisioner_directory", + "eval.tests.test_provisioner.test_install_azure_with_existing_dir_keeps_dir_untouched", + "eval.tests.test_provisioner.test_install_baremetal_requires_configmap", + "eval.tests.test_provisioner.test_install_cattle_aws_fails_on_missing_kubectl", + "eval.tests.test_provisioner.test_install_openstack_fails_on_missing_terraform", + "eval.tests.test_provisioner.test_install_rke_fails_on_missing_kubectl", + "eval.tests.test_provisioner.test_install_stub_provisioner_no_provisioner_dir[azure]", + "eval.tests.test_provisioner.test_install_stub_provisioner_with_existing_provisioner_dir[azure]", + "eval.tests.test_provisioner_stubs.test_baremetal_fails_even_without_preseeded_dir", + "eval.tests.test_provisioner_stubs.test_install_azure_clonegit_creates_provisioner_parent_dir", + "eval.tests.test_provisioner_stubs.test_install_azure_reports_not_implemented_exit_zero", + "eval.tests.test_provisioner_stubs.test_install_baremetal_requires_configmap_exact", + "eval.tests.test_provisioner_stubs.test_install_nutanix_preseed_avoids_kubespray_block", + "eval.tests.test_provisioner_stubs.test_install_nutanix_reports_not_implemented", + "eval.tests.test_provisioner_stubs.test_openstack_scale_reset_remove_upgrade_are_stubs", + "eval.tests.test_provisioner_stubs.test_provisioner_dir_preserve_marker_under_clonegit", + "eval.tests.test_version.test_unknown_version_flag_is_rejected_nonzero", + "eval.tests.test_version.test_version_build_token_is_an_integer_sha_like_placeholder", + "eval.tests.test_version.test_version_does_not_write_extra_files", + "eval.tests.test_version.test_version_help_shows_version_command_available", + "eval.tests.test_version.test_version_line_starts_with_quoted_subcommand_name_shape", + "eval.tests.test_version.test_version_output_is_self_contained_single_line", + "eval.tests.test_version.test_version_prints_exact_static_version_string[argv0-Version:dev (Build: 0)]" + ] + } + }, + "commit": "87af949152286847a553ebbbc82413e9ac230e4b", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.2889196056617265, + "eval_clean_hashes": [ + "a4387ddc08b676ee751e82542039b8be1438440dc06c1cec0f7d1ce1ec054863" + ], + "input_record": { + "commit": "87af949152286847a553ebbbc82413e9ac230e4b", + "commits": 245, + "contributors": 11, + "difficulty": "easy", + "difficulty_code_lines": 1945, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 1945, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.2889196056617265, + "difficulty_test_code_lines": 0, + "full_name": "kubernauts/tk8", + "github_stars": 264, + "input_joern_zip": "go_joern/kubernauts__tk8.zip", + "joern_status": true, + "joern_time": 9.950670063961297, + "language": "go", + "pb_match": [ + { + "pb_fullname": "segmentio/chamber", + "rank": 650, + "similarity": 0.5060784816741943 + } + ], + "repo_age": 8.43, + "repo_path": "go/kubernauts__tk8", + "source": "commit:87af949152286847a553ebbbc82413e9ac230e4b", + "status": "done", + "url": "https://github.com/kubernauts/tk8" + }, + "instance_id": "kubernauts__tk8.87af949", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 1, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 3, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "kubernauts/tk8" +} diff --git a/kubernauts--tk8.87af949/tests/test.sh b/kubernauts--tk8.87af949/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kubernauts--tk8.87af949/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kubernauts--tk8.87af949/tests/workspace.tar.gz b/kubernauts--tk8.87af949/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c957ffd8a09bad40014d34bb16a8d2eea2ef7457 --- /dev/null +++ b/kubernauts--tk8.87af949/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f179628915756624c4a83b541849c016a38326c73255b4121340eeab67d9e9d9 +size 27392 diff --git a/kubernetes--sig-security.e7f5f07/environment/Dockerfile b/kubernetes--sig-security.e7f5f07/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6f371332b0892136e00733449b81644d11444adf --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/environment/Dockerfile @@ -0,0 +1,58 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kubernetes--sig-security.e7f5f07/environment/download.sh b/kubernetes--sig-security.e7f5f07/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..bdbc56ddde15770601cd4ac1d8e4efbb3a3a69cd --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/environment/download.sh @@ -0,0 +1,61 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=local +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module k8s.io/kubernetes/sig-security/srctl + +go 1.25.3 + +require ( + github.com/Kunde21/markdownfmt/v3 v3.1.0 + github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a + github.com/pandatix/go-cvss v0.6.2 + golang.org/x/term v0.36.0 + google.golang.org/protobuf v1.36.10 +) + +require ( + github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/yuin/goldmark v1.7.13 // indirect + golang.org/x/sys v0.37.0 // indirect +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +github.com/Kunde21/markdownfmt/v3 v3.1.0 h1:KiZu9LKs+wFFBQKhrZJrFZwtLnCCWJahL+S+E/3VnM0= +github.com/Kunde21/markdownfmt/v3 v3.1.0/go.mod h1:tPXN1RTyOzJwhfHoon9wUr4HGYmWgVxSQN6VBJDkrVc= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a h1:XHKiGf7vsACh43gFCBb5lOxDjnY6CQYNoQXsO/SlI6k= +github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a/go.mod h1:Eo7R19vlnflsCRdHW1ynyNUyoRwxdaTmTWD9MtKnJTc= +github.com/pandatix/go-cvss v0.6.2 h1:TFiHlzUkT67s6UkelHmK6s1INKVUG7nlKYiWWDTITGI= +github.com/pandatix/go-cvss v0.6.2/go.mod h1:jDXYlQBZrc8nvrMUVVvTG8PhmuShOnKrxP53nOFkt8Q= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA= +github.com/yuin/goldmark v1.7.13/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q= +golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +PROGRAMGYM_GO_SUM_EOF +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kubernetes--sig-security.e7f5f07/environment/executable b/kubernetes--sig-security.e7f5f07/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..dbfd702f4e5b1313d4c4b236b81d04a8f35ed795 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1c6dba511fba7fb4e273ef714e6896d1da62c4f0b1685510b014a85d4f2799c +size 9843485 diff --git a/kubernetes--sig-security.e7f5f07/environment/programgym-go.tar.gz b/kubernetes--sig-security.e7f5f07/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubernetes--sig-security.e7f5f07/environment/workspace.tar.gz b/kubernetes--sig-security.e7f5f07/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..232b7e8b963f8d000af41f162e9a038b1ede923e --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2008e3275b8fc516da8025442e0026258a41a320535be70a36b851ef2af2b961 +size 2075 diff --git a/kubernetes--sig-security.e7f5f07/instruction.md b/kubernetes--sig-security.e7f5f07/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + + +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install `, `go get github.com//`, `pip install `, `apt-get source `, `npm install `, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace + + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kubernetes--sig-security.e7f5f07/solution/solve.sh b/kubernetes--sig-security.e7f5f07/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kubernetes--sig-security.e7f5f07/task.toml b/kubernetes--sig-security.e7f5f07/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f5bbde23f8619875d93f2c859bf88bc25b85c302 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kubernetes--sig-security.e7f5f07" +description = "Synthetic ProgramGym cleanroom reconstruction task for kubernetes/sig-security" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kubernetes__sig-security.e7f5f07" +repository = "kubernetes/sig-security" +commit = "e7f5f07ba369ca8c26a45ed5b8606b96fb76aeea" +language = "go" +difficulty = "unknown" +difficulty_score = 0.0 +test_branches = 4 +test_count = 391 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kubernetes--sig-security.e7f5f07/tests/Dockerfile b/kubernetes--sig-security.e7f5f07/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..bd5f12bacd787ef39a90a560bc0dec968dcdb06e --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_01.tar.gz b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ffeddf2f283a95c023e0c334f99faa10094e78e3 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:771bc3a36fb3693aba4480a956b2d51394aeaa18a0ab24ddde448a0c61b1b01c +size 21922 diff --git a/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_02.tar.gz b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..bba89ac296733db6bb5388ab0d980ded6bc280a3 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4aaa54147cf6a5dae3f68d64e73dbebf7ab40c17cb35e04b6f19aa146db99fd9 +size 22402 diff --git a/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_03.tar.gz b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..57c19489bf5212f6d48b8cb0e5dba75d45ee4735 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb728591211c0a04ec632748870cf708aa3ca86d03438bbf2068314522f002e9 +size 22089 diff --git a/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_04.tar.gz b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4da1e4e0918ad31e9adea81551a65e9fa801c9ab --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a6ea6235ecb5419c8586a9adc297783d560f4270f7945bea557b93343b9fe2e +size 26155 diff --git a/kubernetes--sig-security.e7f5f07/tests/download.sh b/kubernetes--sig-security.e7f5f07/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..bdbc56ddde15770601cd4ac1d8e4efbb3a3a69cd --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/download.sh @@ -0,0 +1,61 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=local +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module k8s.io/kubernetes/sig-security/srctl + +go 1.25.3 + +require ( + github.com/Kunde21/markdownfmt/v3 v3.1.0 + github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a + github.com/pandatix/go-cvss v0.6.2 + golang.org/x/term v0.36.0 + google.golang.org/protobuf v1.36.10 +) + +require ( + github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/yuin/goldmark v1.7.13 // indirect + golang.org/x/sys v0.37.0 // indirect +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +github.com/Kunde21/markdownfmt/v3 v3.1.0 h1:KiZu9LKs+wFFBQKhrZJrFZwtLnCCWJahL+S+E/3VnM0= +github.com/Kunde21/markdownfmt/v3 v3.1.0/go.mod h1:tPXN1RTyOzJwhfHoon9wUr4HGYmWgVxSQN6VBJDkrVc= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a h1:XHKiGf7vsACh43gFCBb5lOxDjnY6CQYNoQXsO/SlI6k= +github.com/ossf/osv-schema/bindings/go v0.0.0-20260129002236-09a17f85b44a/go.mod h1:Eo7R19vlnflsCRdHW1ynyNUyoRwxdaTmTWD9MtKnJTc= +github.com/pandatix/go-cvss v0.6.2 h1:TFiHlzUkT67s6UkelHmK6s1INKVUG7nlKYiWWDTITGI= +github.com/pandatix/go-cvss v0.6.2/go.mod h1:jDXYlQBZrc8nvrMUVVvTG8PhmuShOnKrxP53nOFkt8Q= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA= +github.com/yuin/goldmark v1.7.13/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q= +golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +PROGRAMGYM_GO_SUM_EOF +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kubernetes--sig-security.e7f5f07/tests/executable b/kubernetes--sig-security.e7f5f07/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..dbfd702f4e5b1313d4c4b236b81d04a8f35ed795 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1c6dba511fba7fb4e273ef714e6896d1da62c4f0b1685510b014a85d4f2799c +size 9843485 diff --git a/kubernetes--sig-security.e7f5f07/tests/programgym-go.tar.gz b/kubernetes--sig-security.e7f5f07/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kubernetes--sig-security.e7f5f07/tests/programgym_evaluator.py b/kubernetes--sig-security.e7f5f07/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under represent a result. / +# are stdout/stderr captures and must not be treated as results +# (a leading followed by would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``//tests/.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests//`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kubernetes--sig-security.e7f5f07/tests/programgym_task.json b/kubernetes--sig-security.e7f5f07/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..0f30e8c530c14d0949ddc1b1b879e7005eb1dc5c --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/programgym_task.json @@ -0,0 +1,1089 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_editor_comment_filter.test_first_screen_is_fresh_before_edits", + "reasons": [ + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_editor_comment_filter.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_editor_comment_filter.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_debug_error_branches.test_dot_debug_parse_error_on_invalid_cvss", + "eval.tests.test_debug_error_branches.test_dot_debug_parse_error_then_edit_step_continues", + "eval.tests.test_edit_save.test_clean_save_then_quit_is_clean_nothing_more_to_confirm", + "eval.tests.test_edit_save.test_edit_affected_versions_invalid_rejected", + "eval.tests.test_edit_save.test_edit_affected_versions_valid_multiline", + "eval.tests.test_edit_save.test_edit_cvss_vector_accepted", + "eval.tests.test_edit_save.test_edit_fix_lead_invalid_multiline_is_rejected_at_edit_time", + "eval.tests.test_edit_save.test_edit_github_issue_bad_url_is_rejected", + "eval.tests.test_edit_save.test_edit_github_issue_valid_url_accepted", + "eval.tests.test_edit_save.test_edit_multiline_summary_is_rejected", + "eval.tests.test_edit_save.test_edit_summary_then_save_writes_json", + "eval.tests.test_edit_save.test_edit_then_quit_without_save_leaves_no_file", + "eval.tests.test_edit_save.test_empty_github_issue_accepted_and_saved", + "eval.tests.test_edit_save.test_invalid_github_issue_url_classification", + "eval.tests.test_edit_save.test_save_json_structure_is_export_complete", + "eval.tests.test_edit_save.test_save_without_editing_writes_empty_steps_json", + "eval.tests.test_edit_save.test_saved_state_restores_on_next_run", + "eval.tests.test_edit_save.test_uppercase_s_saves_as_lowercase", + "eval.tests.test_editor_comment_filter.test_edit_fix_lead_empty_exercises_prepopulate_branch", + "eval.tests.test_editor_comment_filter.test_edit_fix_lead_with_inline_comment_is_filtered", + "eval.tests.test_editor_comment_filter.test_editor_all_content_inside_comment_empties_value", + "eval.tests.test_editor_comment_filter.test_editor_comment_spanning_lines_strips_block", + "eval.tests.test_editor_comment_filter.test_editor_empty_output_stored_as_empty_string", + "eval.tests.test_editor_comment_filter.test_editor_lone_close_marker_line_is_dropped", + "eval.tests.test_editor_comment_filter.test_editor_strips_self_contained_html_comments[\\nbody\\n-body]", + "eval.tests.test_editor_comment_filter.test_editor_strips_self_contained_html_comments[a\\n\\nb\\n\\nc-a\\nb\\nc]", + "eval.tests.test_editor_comment_filter.test_editor_strips_self_contained_html_comments[kept line\\n\\nkept too-kept line\\nkept too]", + "eval.tests.test_editor_comment_filter.test_first_screen_is_fresh_before_edits", + "eval.tests.test_editor_failure.test_editor_failing_script_nonzero_exit_reports_status", + "eval.tests.test_editor_failure.test_editor_missing_binary_after_restore_fails_edit", + "eval.tests.test_editor_failure.test_editor_missing_binary_fails_edit", + "eval.tests.test_editor_failure.test_editor_nonexistent_and_unset_without_common_editors_fails", + "eval.tests.test_export.test_export_all_writes_three_files", + "eval.tests.test_export.test_export_email_writes_markdown", + "eval.tests.test_export.test_export_fails_when_affected_versions_invalid", + "eval.tests.test_export.test_export_fails_when_cvss_invalid", + "eval.tests.test_export.test_export_fresh_empty_state_writes_issue", + "eval.tests.test_export.test_export_invalid_format_is_rejected", + "eval.tests.test_export.test_export_issue_contains_edited_summary", + "eval.tests.test_export.test_export_issue_omits_empty_sections", + "eval.tests.test_export.test_export_issue_writes_markdown_0600", + "eval.tests.test_export.test_export_slack_writes_markdown", + "eval.tests.test_export.test_export_uppercase_format_key_normalizes", + "eval.tests.test_interactive_navigation.test_ctrl_c_clean_quits", + "eval.tests.test_interactive_navigation.test_ctrl_c_dirty_requires_confirmation", + "eval.tests.test_interactive_navigation.test_debug_dot_on_populated_restored_state_is_exact", + "eval.tests.test_interactive_navigation.test_debug_dot_prints_processed_data", + "eval.tests.test_interactive_navigation.test_debug_dot_shows_edited_summary", + "eval.tests.test_interactive_navigation.test_enter_edits_focused_step_after_nav_j", + "eval.tests.test_interactive_navigation.test_enter_edits_focused_step_after_nav_k_wrap", + "eval.tests.test_interactive_navigation.test_invalid_command_reports_status", + "eval.tests.test_interactive_navigation.test_invalid_command_variants[%-invalid command '%']", + "eval.tests.test_interactive_navigation.test_invalid_command_variants[[-invalid command '[']", + "eval.tests.test_interactive_navigation.test_multiple_edits_then_save_persists_both", + "eval.tests.test_interactive_navigation.test_quit_clean_exits_zero", + "eval.tests.test_interactive_navigation.test_quit_dirty_requires_confirmation", + "eval.tests.test_interactive_navigation.test_round_loop_state_prints_via_stringer", + "eval.tests.test_interactive_navigation.test_scroll_next_focus_j", + "eval.tests.test_interactive_navigation.test_scroll_next_wraps_after_twelve", + "eval.tests.test_interactive_navigation.test_scroll_previous_focus_k", + "eval.tests.test_interactive_navigation.test_step_key_a_edits_github_issue", + "eval.tests.test_interactive_navigation.test_step_key_b_edits_fix_lead_and_focus_wraps", + "eval.tests.test_interactive_navigation.test_step_number_gotoa_enters_edit_mode", + "eval.tests.test_interactive_navigation.test_uppercase_q_quits_clean", + "eval.tests.test_interactive_navigation.test_uppercase_step_key_edits[A-10-https://github.com/kubernetes/kubernetes/issues/136680]", + "eval.tests.test_interactive_navigation.test_uppercase_step_key_edits[B-11-Tabitha Sable]", + "eval.tests.test_main_cli.test_argument_is_uppercased_and_json_suffix_stripped[CVE-2026-3333-CVE-2026-3333]", + "eval.tests.test_main_cli.test_argument_is_uppercased_and_json_suffix_stripped[CvE-2025-2222.json-CVE-2025-2222]", + "eval.tests.test_main_cli.test_argument_is_uppercased_and_json_suffix_stripped[cVe-2024-8888-CVE-2024-8888]", + "eval.tests.test_main_cli.test_argument_is_uppercased_and_json_suffix_stripped[cve-2024-5678-CVE-2024-5678]", + "eval.tests.test_main_cli.test_argument_is_uppercased_and_json_suffix_stripped[cve-2025-0001.JsOn-CVE-2025-0001]", + "eval.tests.test_main_cli.test_extra_positional_argument_is_ignored", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[ CVE-2024-1234]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE-1234]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE-123]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE-2024-12 34]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE-2024-567]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE-2024-]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[CVE20245678]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[XVE-2024-1234]", + "eval.tests.test_main_cli.test_invalid_cve_returns_error[]", + "eval.tests.test_main_cli.test_json_suffix_opens_state_for_trimmed_cve", + "eval.tests.test_main_cli.test_md_suffix_is_not_stripped_and_rejected", + "eval.tests.test_main_cli.test_no_argument_does_not_touch_files", + "eval.tests.test_main_cli.test_no_argument_prints_placeholder_golden", + "eval.tests.test_main_cli.test_valid_cve_boundaries_accepted[CVE-0000-0000]", + "eval.tests.test_main_cli.test_valid_cve_boundaries_accepted[CVE-2024-0000]", + "eval.tests.test_main_cli.test_valid_cve_boundaries_accepted[CVE-2024-1234]", + "eval.tests.test_main_cli.test_valid_cve_boundaries_accepted[CVE-2024-999999]", + "eval.tests.test_main_cli.test_valid_cve_renders_exact_fresh_screen", + "eval.tests.test_restore_cve.test_restore_absent_file_is_fresh_state", + "eval.tests.test_restore_cve.test_restore_ignores_unknown_step_keys", + "eval.tests.test_restore_cve.test_restore_invalid_fix_lead_value_fails", + "eval.tests.test_restore_cve.test_restore_invalid_json_fails", + "eval.tests.test_restore_cve.test_restore_invalid_step_value_fails", + "eval.tests.test_restore_cve.test_restore_mismatched_cve_fails", + "eval.tests.test_restore_cve.test_restore_then_edit_and_save_preserves_other_steps", + "eval.tests.test_restore_cve.test_restore_valid_file_shows_exact_values", + "eval.tests.test_restore_cve.test_state_file_as_directory_causes_read_error" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_affected_versions_extra.test_affected_versions_blank_and_whitespace_only_committed_empty", + "eval.tests.test_affected_versions_extra.test_affected_versions_empty_fixed_version_rejected", + "eval.tests.test_affected_versions_extra.test_affected_versions_fixed_version_without_v_prefix_committed", + "eval.tests.test_affected_versions_extra.test_affected_versions_introduced_version_committed", + "eval.tests.test_affected_versions_extra.test_affected_versions_missing_separator_rejected", + "eval.tests.test_affected_versions_extra.test_affected_versions_multiline_introduced_same_component_committed", + "eval.tests.test_editor_errors.test_editor_deleting_temp_file_aborts", + "eval.tests.test_editor_errors.test_editor_failure_code_and_message", + "eval.tests.test_editor_errors.test_editor_leaving_placeholder_untouched_yields_empty", + "eval.tests.test_editor_errors.test_editor_not_found_when_editord_unset_and_no_editor_on_path", + "eval.tests.test_editor_errors.test_multiline_edit_rejected_by_summary_validation", + "eval.tests.test_editor_errors.test_unwritable_tmpdir_aborts_editor", + "eval.tests.test_editor_strip.test_editor_recording_which_editor_ran", + "eval.tests.test_editor_strip.test_read_from_editor_empty_edits_render_no_value[ \\n \\n]", + "eval.tests.test_editor_strip.test_read_from_editor_empty_edits_render_no_value[\\n\\n\\n]", + "eval.tests.test_editor_strip.test_read_from_editor_empty_edits_render_no_value[]", + "eval.tests.test_editor_strip.test_read_from_editor_empty_edits_render_no_value[x\\nkeep\\n-keep]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[\\nkeep\\n-keep]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[\\nvisible\\n-visible]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[\\nkeep\\n-keep]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[<!--x-->ends here\\nok\\n-ok]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[Just a plain single line.\\n-Just a plain single line.]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[a --> b <!-- c\\nkeep\\n-keep]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[a <!-- start\\nmid\\nend --> b\\nc\\n-c]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[a\\n\\nb\\n-a\\n\\nb]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[before <!--x--> after\\nkeep\\n-keep]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[first\\nsecond\\n-first\\nsecond]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[nested <!-- v\\nstill -->x\\nout\\n-out]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[one\\n<!-- c1\\nc2\\n-->two\\nthree\\n-one\\nthree]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[opening\\n<!-- unterminated\\n-opening]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[opening\\nfold-->here\\ntail\\n-opening\\ntail]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[tab\\tseparated\\nsecond\\n-tab\\tseparated\\nsecond]", + "eval.tests.test_editor_strip.test_read_from_editor_strips_comments[value with <!-- a --> mid\\nline\\n-line]", + "eval.tests.test_entry_points.test_invalid_cve_rejected", + "eval.tests.test_entry_points.test_no_argument_prints_placeholder_issue", + "eval.tests.test_entry_points.test_save_then_restore_from_file", + "eval.tests.test_entry_points.test_uppercase_cve_and_dotjson_suffix_normalized", + "eval.tests.test_entry_points.test_valid_cve_enters_run_loop", + "eval.tests.test_prompt_byte_keys.test_ctrl_c_quits_clean_without_dirty", + "eval.tests.test_prompt_byte_keys.test_dot_dumps_processed_data", + "eval.tests.test_prompt_byte_keys.test_exports_issue_md", + "eval.tests.test_prompt_byte_keys.test_j_scrolls_focus_forward", + "eval.tests.test_prompt_byte_keys.test_k_scrolls_focus_backward_and_wraps", + "eval.tests.test_prompt_byte_keys.test_piped_stdin_raw_mode_error", + "eval.tests.test_prompt_byte_keys.test_q_quits_clean_without_dirty", + "eval.tests.test_prompt_byte_keys.test_quit_with_dirty_requires_confirm", + "eval.tests.test_prompt_byte_keys.test_s_saves_state_to_json", + "eval.tests.test_prompt_byte_keys.test_step_key_edits_focused_step", + "eval.tests.test_prompt_byte_keys.test_z_invalid_command_status", + "eval.tests.test_prompt_commands.test_control_byte_invalid_with_go_quote_escape", + "eval.tests.test_prompt_commands.test_ctrl_d_invalid_command", + "eval.tests.test_prompt_commands.test_dot_dump_reflects_committed_description", + "eval.tests.test_prompt_commands.test_export_creates_only_expected_files[a-exts3]", + "eval.tests.test_prompt_commands.test_export_creates_only_expected_files[i-exts0]", + "eval.tests.test_prompt_commands.test_export_creates_only_expected_files[m-exts1]", + "eval.tests.test_prompt_commands.test_export_creates_only_expected_files[s-exts2]", + "eval.tests.test_prompt_commands.test_export_email_md", + "eval.tests.test_prompt_commands.test_export_slack_md", + "eval.tests.test_prompt_commands.test_invalid_export_format_after_x", + "eval.tests.test_prompt_commands.test_uppercase_q_quits_clean", + "eval.tests.test_prompt_commands.test_uppercase_s_saves_state", + "eval.tests.test_prompt_commands.test_uppercase_scroll_keys_not_recognized[J]", + "eval.tests.test_prompt_commands.test_uppercase_scroll_keys_not_recognized[K]", + "eval.tests.test_prompt_commands.test_uppercase_scroll_keys_not_recognized[L]", + "eval.tests.test_prompt_commands.test_uppercase_scroll_keys_not_recognized[M]", + "eval.tests.test_prompt_commands.test_uppercase_x_exports_issue", + "eval.tests.test_restore_and_export_errors.test_export_issue_reflects_committed_description", + "eval.tests.test_restore_and_export_errors.test_export_target_collides_with_directory_status", + "eval.tests.test_restore_and_export_errors.test_restore_cve_mismatch_between_arg_and_file", + "eval.tests.test_restore_and_export_errors.test_restore_invalid_json_unmarshal_error", + "eval.tests.test_restore_and_export_errors.test_restore_rejects_step_violating_validator[fix_lead-multi\\nline-failed validating value from step fix_lead from file CVE-2024-0001.json: invalid fix lead name, should contain only one line]", + "eval.tests.test_restore_and_export_errors.test_restore_rejects_step_violating_validator[github_issue-not-a-url-failed validating value from step github_issue from file CVE-2024-0001.json: invalid GitHub issue URL \"not-a-url\", expected format: https://github.com/ORG/REPO/issues/NUMBER]", + "eval.tests.test_restore_and_export_errors.test_restore_rejects_step_violating_validator[summary-multi\\nline-failed validating value from step summary from file CVE-2024-0001.json: invalid summary, should contain only one line]", + "eval.tests.test_restore_and_export_errors.test_restore_when_state_file_is_directory_read_error", + "eval.tests.test_step_edit_validation.test_fix_lead_multiline_rejected", + "eval.tests.test_step_edit_validation.test_fix_lead_single_line_committed", + "eval.tests.test_step_edit_validation.test_github_issue_empty_allowed", + "eval.tests.test_step_edit_validation.test_github_issue_invalid_url_rejected", + "eval.tests.test_step_edit_validation.test_github_issue_valid_url_committed", + "eval.tests.test_step_edit_validation.test_reject_then_fix_stateful_chain", + "eval.tests.test_step_edit_validation.test_summary_valid_single_line_committed", + "eval.tests.test_step_edit_validation.test_uppercase_a_b_step_keys_edit", + "eval.tests.test_step_slots_and_placeholder.test_affected_versions_invalid_line_rejected", + "eval.tests.test_step_slots_and_placeholder.test_affected_versions_mismatched_component_rejected", + "eval.tests.test_step_slots_and_placeholder.test_affected_versions_multi_line_valid_committed", + "eval.tests.test_step_slots_and_placeholder.test_cvss_valid_url_committed", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_contains_instructions_block", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[0-placeholder_step0_summary.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[1-placeholder_step1_cvss.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[3-placeholder_step3_vulnerable.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[4-placeholder_step4_affected.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[5-placeholder_step5_upgrade.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[6-placeholder_step6_mitigate.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[7-placeholder_step7_detection.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[8-placeholder_step8_additional.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[9-placeholder_step9_acknowledgements.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[a-placeholder_stepa_issue.md]", + "eval.tests.test_step_slots_and_placeholder.test_editor_placeholder_step_title_rendered[b-placeholder_stepb_fixlead.md]", + "eval.tests.test_step_slots_and_placeholder.test_markdown_step_slots_commit[5-5-upgrade to v1.32.9\\n]", + "eval.tests.test_step_slots_and_placeholder.test_markdown_step_slots_commit[6-6-mitigate by patching\\n]", + "eval.tests.test_step_slots_and_placeholder.test_markdown_step_slots_commit[7-7-detect via audit logs\\n]", + "eval.tests.test_step_slots_and_placeholder.test_markdown_step_slots_commit[8-8-additional context\\n]", + "eval.tests.test_step_slots_and_placeholder.test_markdown_step_slots_commit[9-9-thanks to the reporter\\n]", + "eval.tests.test_step_slots_and_placeholder.test_placeholder_on_reedit_embeds_committed_value", + "eval.tests.test_step_slots_and_placeholder.test_vulnerable_markdown_step_committed" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_export.test_export_email_writes_email_file", + "reasons": [ + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_export.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_export.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_export.test_export_slack_writes_slack_file", + "reasons": [ + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_export.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_export.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_cli_entry.test_excessively_long_id_rejected_exact", + "eval.tests.test_cli_entry.test_fresh_state_render_exact", + "eval.tests.test_cli_entry.test_fresh_state_reports_unsaved_status", + "eval.tests.test_cli_entry.test_lowercase_cve_argument_normalized_upper", + "eval.tests.test_cli_entry.test_malformed_separator_rejected_exact", + "eval.tests.test_cli_entry.test_minimal_valid_cve_accepted", + "eval.tests.test_cli_entry.test_no_arg_prints_placeholder_issue_exact", + "eval.tests.test_cli_entry.test_non_cve_argument_rejected_exact", + "eval.tests.test_cli_entry.test_short_id_rejected_exact", + "eval.tests.test_cli_entry.test_short_year_rejected_exact", + "eval.tests.test_cli_entry.test_trailing_dot_json_stripped_for_lookup", + "eval.tests.test_edit_paths_and_restore_errors.test_enter_edits_current_focus_step", + "eval.tests.test_edit_paths_and_restore_errors.test_enter_edits_multiline_markdown_step", + "eval.tests.test_edit_paths_and_restore_errors.test_enter_edits_wrapped_fix_lead", + "eval.tests.test_edit_paths_and_restore_errors.test_enter_invalid_multiline_summary_rejected", + "eval.tests.test_edit_paths_and_restore_errors.test_fix_lead_enter_skips_prepopulate_when_value_present", + "eval.tests.test_edit_paths_and_restore_errors.test_reedit_same_step_replaces_not_appends", + "eval.tests.test_edit_paths_and_restore_errors.test_render_escapes_backslash_value", + "eval.tests.test_edit_paths_and_restore_errors.test_render_escapes_double_quote_value", + "eval.tests.test_edit_paths_and_restore_errors.test_render_escapes_tab_value", + "eval.tests.test_edit_paths_and_restore_errors.test_restore_directory_read_error_exact", + "eval.tests.test_export.test_email_export_includes_edited_summary_in_subject", + "eval.tests.test_export.test_export_email_writes_email_file", + "eval.tests.test_export.test_export_issue_populated_from_edited_summary", + "eval.tests.test_export.test_export_slack_writes_slack_file", + "eval.tests.test_export.test_exported_files_have_private_permissions", + "eval.tests.test_export.test_invalid_export_format_rejected", + "eval.tests.test_export.test_slack_export_mentions_edited_summary", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_fix_lead_explicit_value_overrides_prepopulate", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_fix_lead_prepopulate_empty_when_git_missing", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_fix_lead_prepopulated_from_git_config", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_restore_full_catalog_roundtrip_lossless", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_restore_ignores_unknown_step_key", + "eval.tests.test_fix_lead_prepopulate_and_restore.test_restore_without_build_info_field", + "eval.tests.test_focus_navigation.test_ctrl_c_quits_clean", + "eval.tests.test_focus_navigation.test_gotofocus_edits_selected_step_and_advances", + "eval.tests.test_focus_navigation.test_j_advances_one_step", + "eval.tests.test_focus_navigation.test_j_reaches_last_step_fix_lead", + "eval.tests.test_focus_navigation.test_j_wraps_from_last_to_first", + "eval.tests.test_focus_navigation.test_jj_k_navigates_back_one", + "eval.tests.test_focus_navigation.test_k_moves_back_one_step", + "eval.tests.test_focus_navigation.test_k_wraps_from_first_to_last", + "eval.tests.test_focus_navigation.test_uppercase_A_selects_github_issue_step", + "eval.tests.test_focus_navigation.test_uppercase_B_selects_fix_lead_step", + "eval.tests.test_focus_navigation.test_uppercase_Q_quits_clean", + "eval.tests.test_focus_navigation.test_uppercase_S_saves_state", + "eval.tests.test_focus_navigation.test_uppercase_X_exports_issue", + "eval.tests.test_persistence.test_clean_quit_has_no_confirm", + "eval.tests.test_persistence.test_edit_marks_dirty_and_requires_quit_confirm", + "eval.tests.test_persistence.test_edit_then_save_persists_value", + "eval.tests.test_persistence.test_edited_value_persists_across_focus_moves", + "eval.tests.test_persistence.test_fresh_state_status_shows_only_once", + "eval.tests.test_persistence.test_invalid_command_rejected", + "eval.tests.test_persistence.test_long_step_value_truncated_in_middle", + "eval.tests.test_persistence.test_resave_overwrites_existing_json", + "eval.tests.test_persistence.test_restore_cve_mismatch_fails", + "eval.tests.test_persistence.test_restore_invalid_affected_versions_rejected", + "eval.tests.test_persistence.test_restore_invalid_github_issue_rejected", + "eval.tests.test_persistence.test_restore_invalid_step_value_fails", + "eval.tests.test_persistence.test_restore_malformed_json_fails", + "eval.tests.test_persistence.test_restore_renders_handcrafted_state", + "eval.tests.test_persistence.test_restore_valid_affected_versions_revalidated_ok", + "eval.tests.test_persistence.test_restore_valid_cvss_value_roundtrip", + "eval.tests.test_persistence.test_save_clears_dirty_flag", + "eval.tests.test_persistence.test_save_then_restore_roundtrip", + "eval.tests.test_persistence.test_save_writes_complete_state_json", + "eval.tests.test_step_validation.test_affected_versions_component_mismatch_rejected", + "eval.tests.test_step_validation.test_affected_versions_empty_component_rejected", + "eval.tests.test_step_validation.test_affected_versions_garbage_rejected", + "eval.tests.test_step_validation.test_affected_versions_introduced_version_accepted", + "eval.tests.test_step_validation.test_affected_versions_valid_accepted", + "eval.tests.test_step_validation.test_fix_lead_multiline_rejected", + "eval.tests.test_step_validation.test_fix_lead_single_line_accepted", + "eval.tests.test_step_validation.test_github_issue_bad_url_rejected", + "eval.tests.test_step_validation.test_github_issue_empty_allowed", + "eval.tests.test_step_validation.test_github_issue_http_scheme_accepted", + "eval.tests.test_step_validation.test_github_issue_trailing_slash_accepted", + "eval.tests.test_step_validation.test_github_issue_valid_url_accepted", + "eval.tests.test_step_validation.test_summary_multiline_rejected", + "eval.tests.test_step_validation.test_summary_single_line_accepted", + "eval.tests.test_step_validation.test_summary_trailing_newline_stripped", + "eval.tests.test_step_value_acceptance.test_cvss_step_rejects_nothing_but_empty_aborts", + "eval.tests.test_step_value_acceptance.test_description_multiline_stored_and_saved", + "eval.tests.test_step_value_acceptance.test_non_validator_step_accepts_graphical_emoji_value", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[1-1-CVSS-CVSS:3.0/AV:N/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:L]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[2-2-Description-A crafted certificate bypasses trust validation]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[3-3-Am I vulnerable?-check the manager container audit logs]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[5-5-How to upgrade?-upgrade the kube-apiserver to a patched minor]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[6-6-How to mitigate?-enable OwnerReferencesPermissionEnforcement]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[7-7-Detection-analyze API audit logs for node patch requests]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[8-8-Additional Details-no further details are currently known]", + "eval.tests.test_step_value_acceptance.test_non_validator_step_edit_stored_exact[9-9-Acknowledgements-reported by the Kubernetes Security team]", + "eval.tests.test_step_value_acceptance.test_truncate_middle_at_exact_width_not_truncated", + "eval.tests.test_step_value_acceptance.test_truncate_middle_beyond_width_uses_ellipsis", + "eval.tests.test_version_buildinfo.test_build_info_version_in_saved_state", + "eval.tests.test_version_buildinfo.test_exports_all_formats_issue_email_slack", + "eval.tests.test_version_buildinfo.test_issue_export_footer_contains_build_info" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_additional_paths.test_debug_dot_reports_cvss_parse_error_status", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_editor_strips_html_comment_lines_from_committed_value", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_email_renders_additional_details_and_acknowledgements_blocks", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_issue_vulnerable_section_gated_on_value", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_long_summary_is_truncated_with_ellipsis_in_tui_list", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_uppercase_a_edits_github_issue_step", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_additional_paths.test_uppercase_b_edits_fix_lead_step", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_additional_paths.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_affected_versions.test_editor_accepts_valid_multiline_and_commits", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_affected_versions.test_editor_rejects_malformed_second_line_only", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_affected_versions.test_editor_rejects_malformed_version_line", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_affected_versions.test_editor_rejects_mismatched_component_line", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_affected_versions.test_mismatched_components_rejected_at_restore", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_affected_versions.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cvss_parse.test_cvss_url_with_unparseable_fragment_reports_parse_url_error", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_cvss_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cvss_parse.test_cvss_url_without_fragment_yields_empty_vector", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_cvss_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cvss_parse.test_cvss_v2_prefix_is_not_a_valid_2_0_vector", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_cvss_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cvss_parse.test_cvss_v4_high_band_rating", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_cvss_parse.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_cvss_parse.test_invalid_cvss_vector_fails_export_without_writing_file", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_cvss_parse.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_github_issue.test_editor_rejects_invalid_github_issue", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_github_issue.test_github_issue_subdomain_host_rejected", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_github_issue.test_invalid_github_issue_rejected_in_restore", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_github_issue.test_non_github_host_rejected_in_editor", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_github_issue.test_non_numeric_issue_number_rejected_at_restore", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_github_issue.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_goto_focus_by_alpha_key_b", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_goto_focus_by_digit_key", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_invalid_single_byte_command_reports_status", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_j_scrolls_focus_forward", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_k_scrolls_focus_backward", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_interaction.test_uppercase_command_keys_are_not_rejected", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_interaction.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_markdown_and_steps.test_fix_lead_newline_rejected", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_markdown_and_steps.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_markdown_and_steps.test_summary_multi_line_rejected_at_restore", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_markdown_and_steps.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_markdown_and_steps.test_summary_single_line_validation_in_editor", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_markdown_and_steps.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_osv_export.test_issue_template_embeds_osv_string", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_osv_export.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_template_details.test_email_affected_and_fixed_versions_with_introduced", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_template_details.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_template_details.test_issue_affected_versions_bullets_with_introduced", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_template_details.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_templates.test_export_invalid_format_keeps_loop", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_templates.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_templates.test_issue_template_renders_cvedata_fields", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_templates.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_templates.test_restore_validates_steps_from_file", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_templates.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_templates.test_uppercase_e_is_still_invalid_export_format", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_templates.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_additional_paths.test_clean_quit_exits_zero_without_dirty_confirm", + "eval.tests.test_additional_paths.test_debug_dot_reports_cvss_parse_error_status", + "eval.tests.test_additional_paths.test_detection_step_is_markdown_linted", + "eval.tests.test_additional_paths.test_editor_keeps_text_when_no_comment_marker", + "eval.tests.test_additional_paths.test_editor_strips_html_comment_lines_from_committed_value", + "eval.tests.test_additional_paths.test_email_renders_additional_details_and_acknowledgements_blocks", + "eval.tests.test_additional_paths.test_issue_vulnerable_section_gated_on_value", + "eval.tests.test_additional_paths.test_long_summary_is_truncated_with_ellipsis_in_tui_list", + "eval.tests.test_additional_paths.test_restore_ignores_unknown_step_keys_but_keeps_known_step", + "eval.tests.test_additional_paths.test_restore_rejects_cve_mismatch_between_arg_and_file", + "eval.tests.test_additional_paths.test_restore_rejects_invalid_json_state_file", + "eval.tests.test_additional_paths.test_save_reports_success_and_persists_exact_json", + "eval.tests.test_additional_paths.test_short_summary_is_not_truncated", + "eval.tests.test_additional_paths.test_uppercase_a_edits_github_issue_step", + "eval.tests.test_additional_paths.test_uppercase_b_edits_fix_lead_step", + "eval.tests.test_additional_paths.test_uppercase_s_save_is_dispatch", + "eval.tests.test_additional_paths.test_valid_restore_reports_exact_status", + "eval.tests.test_affected_versions.test_blank_lines_within_versions_are_skipped", + "eval.tests.test_affected_versions.test_delete_less_sigil_variants", + "eval.tests.test_affected_versions.test_editor_accepts_valid_multiline_and_commits", + "eval.tests.test_affected_versions.test_editor_rejects_malformed_second_line_only", + "eval.tests.test_affected_versions.test_editor_rejects_malformed_version_line", + "eval.tests.test_affected_versions.test_editor_rejects_mismatched_component_line", + "eval.tests.test_affected_versions.test_empty_affected_versions_yield_no_affected", + "eval.tests.test_affected_versions.test_explicit_introduced_version_event", + "eval.tests.test_affected_versions.test_mismatched_components_rejected_at_restore", + "eval.tests.test_affected_versions.test_multiple_versions_same_component_grouped", + "eval.tests.test_affected_versions.test_single_affected_version_range", + "eval.tests.test_affected_versions.test_v_prefix_and_version_formats", + "eval.tests.test_cli_entry.test_dot_json_suffix_is_stripped_and_uppercased", + "eval.tests.test_cli_entry.test_extra_dot_suffix_not_stripped_because_not_json", + "eval.tests.test_cli_entry.test_invalid_cve_name_errors_to_stderr", + "eval.tests.test_cli_entry.test_lowercase_cve_normalised_to_uppercase", + "eval.tests.test_cli_entry.test_no_argument_prints_exact_placeholder_issue", + "eval.tests.test_cli_entry.test_placeholder_issue_uses_lean_markdown_skeleton", + "eval.tests.test_cli_entry.test_short_cve_number_suffix_rejected", + "eval.tests.test_cli_entry.test_uppercase_json_suffix_is_stripped", + "eval.tests.test_cli_entry.test_valid_cve_requires_tty_and_reports_raw_mode_error", + "eval.tests.test_cvss_parse.test_cvss_medium_and_low_rating_bands[CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L-CVSS_V3-LOW-3.3]", + "eval.tests.test_cvss_parse.test_cvss_medium_and_low_rating_bands[CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N-CVSS_V3-MEDIUM-4.8]", + "eval.tests.test_cvss_parse.test_cvss_medium_and_low_rating_bands[CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N-CVSS_V4-MEDIUM-5.3]", + "eval.tests.test_cvss_parse.test_cvss_url_fragment_becomes_vector", + "eval.tests.test_cvss_parse.test_cvss_url_with_unparseable_fragment_reports_parse_url_error", + "eval.tests.test_cvss_parse.test_cvss_url_without_fragment_yields_empty_vector", + "eval.tests.test_cvss_parse.test_cvss_v2_prefix_is_not_a_valid_2_0_vector", + "eval.tests.test_cvss_parse.test_cvss_v4_high_band_rating", + "eval.tests.test_cvss_parse.test_cvss_vector_family_maps_to_osv_severity[AV:N/AC:L/Au:N/C:P/I:P/A:P-CVSS_V2--7.5]", + "eval.tests.test_cvss_parse.test_cvss_vector_family_maps_to_osv_severity[CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H-CVSS_V3-CRITICAL-9.8]", + "eval.tests.test_cvss_parse.test_cvss_vector_family_maps_to_osv_severity[CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H-CVSS_V3-CRITICAL-9.8]", + "eval.tests.test_cvss_parse.test_cvss_vector_family_maps_to_osv_severity[CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N-CVSS_V4-CRITICAL-9.3]", + "eval.tests.test_cvss_parse.test_email_reports_cvss_score[AV:N/AC:L/Au:N/C:P/I:P/A:P-7.5]", + "eval.tests.test_cvss_parse.test_email_reports_cvss_score[CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H-9.8]", + "eval.tests.test_cvss_parse.test_email_reports_cvss_score[CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N-9.3]", + "eval.tests.test_cvss_parse.test_email_reports_severity_rating[AV:N/AC:L/Au:N/C:P/I:P/A:P-This issue has been rated **** ([CVSS calculator]]", + "eval.tests.test_cvss_parse.test_email_reports_severity_rating[CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H-This issue has been rated **CRITICAL** ([CVSS calculator]]", + "eval.tests.test_cvss_parse.test_email_reports_severity_rating[CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N-This issue has been rated **CRITICAL** ([CVSS calculator]]", + "eval.tests.test_cvss_parse.test_empty_cvss_handle_fresh_state", + "eval.tests.test_cvss_parse.test_invalid_cvss_vector_fails_export_without_writing_file", + "eval.tests.test_cvss_parse.test_invalid_cvss_vector_with_cvss40_prefix_aborts", + "eval.tests.test_cvss_parse.test_missing_cvss_yields_no_severity", + "eval.tests.test_github_issue.test_editor_rejects_invalid_github_issue", + "eval.tests.test_github_issue.test_email_mentions_github_issue", + "eval.tests.test_github_issue.test_empty_github_issue_omits_reference", + "eval.tests.test_github_issue.test_github_issue_subdomain_host_rejected", + "eval.tests.test_github_issue.test_http_and_https_schemes_accepted", + "eval.tests.test_github_issue.test_invalid_github_issue_accepts_trailing_slash", + "eval.tests.test_github_issue.test_invalid_github_issue_rejected_in_restore", + "eval.tests.test_github_issue.test_non_github_host_rejected_in_editor", + "eval.tests.test_github_issue.test_non_numeric_issue_number_rejected_at_restore", + "eval.tests.test_github_issue.test_slack_mentions_github_issue", + "eval.tests.test_github_issue.test_valid_github_issue_adds_advisory_reference", + "eval.tests.test_interaction.test_debug_dump_exposes_affected_versions", + "eval.tests.test_interaction.test_debug_dump_exposes_github_issue_fields", + "eval.tests.test_interaction.test_debug_dump_exposes_parsed_cvss_vector", + "eval.tests.test_interaction.test_dirty_state_requires_confirm_to_quit", + "eval.tests.test_interaction.test_goto_focus_by_alpha_key_b", + "eval.tests.test_interaction.test_goto_focus_by_digit_key", + "eval.tests.test_interaction.test_invalid_single_byte_command_reports_status", + "eval.tests.test_interaction.test_j_scrolls_focus_forward", + "eval.tests.test_interaction.test_k_scrolls_focus_backward", + "eval.tests.test_interaction.test_uppercase_X_enters_export_flow", + "eval.tests.test_interaction.test_uppercase_command_keys_are_not_rejected", + "eval.tests.test_markdown_and_steps.test_additional_details_section", + "eval.tests.test_markdown_and_steps.test_fix_lead_newline_rejected", + "eval.tests.test_markdown_and_steps.test_fix_lead_renders_in_email_only", + "eval.tests.test_markdown_and_steps.test_markdown_code_block_is_normalized", + "eval.tests.test_markdown_and_steps.test_markdown_description_is_linted_and_trimmed", + "eval.tests.test_markdown_and_steps.test_markdown_description_reaches_issue_body_and_osv_details", + "eval.tests.test_markdown_and_steps.test_summary_multi_line_rejected_at_restore", + "eval.tests.test_markdown_and_steps.test_summary_single_line_validation_in_editor", + "eval.tests.test_markdown_and_steps.test_vulnerable_and_upgrade_route_to_specific_slots", + "eval.tests.test_osv_export.test_issue_template_buildinfo_marker", + "eval.tests.test_osv_export.test_issue_template_embeds_osv_string", + "eval.tests.test_osv_export.test_issue_template_plumbing_directives", + "eval.tests.test_osv_export.test_osv_affected_package_and_range_shape", + "eval.tests.test_osv_export.test_osv_credits_from_acknowledgements", + "eval.tests.test_osv_export.test_osv_cveorg_advisory_reference_always_present", + "eval.tests.test_osv_export.test_osv_cvss_severity_and_score_vector", + "eval.tests.test_osv_export.test_osv_full_reference_set", + "eval.tests.test_osv_export.test_osv_json_is_indented_two_spaces", + "eval.tests.test_osv_export.test_osv_modified_is_rfc3339_timestamp", + "eval.tests.test_osv_export.test_osv_no_credits_when_no_acknowledgements", + "eval.tests.test_osv_export.test_osv_reference_objects_carry_only_type_and_url", + "eval.tests.test_osv_export.test_osv_schema_and_identity_fields", + "eval.tests.test_osv_export.test_osv_with_full_state_reference_and_credit_sets", + "eval.tests.test_template_details.test_email_affected_and_fixed_versions_with_introduced", + "eval.tests.test_template_details.test_email_no_fixed_versions_header_when_no_versions", + "eval.tests.test_template_details.test_email_renders_oss_security_cross_post", + "eval.tests.test_template_details.test_email_renders_security_issue_team_block", + "eval.tests.test_template_details.test_email_without_cvss_uses_assigned_sentence", + "eval.tests.test_template_details.test_issue_affected_versions_bullets_with_introduced", + "eval.tests.test_template_details.test_issue_cvss_rating_link_line", + "eval.tests.test_template_details.test_issue_title_without_summary_is_bare_cve", + "eval.tests.test_template_details.test_slack_full_advisory_one_liner_exact", + "eval.tests.test_template_details.test_slack_omits_github_tail_when_no_issue", + "eval.tests.test_template_details.test_slack_unrated_v2_renders_empty_rating_slot", + "eval.tests.test_templates.test_all_export_writes_issue_email_slack", + "eval.tests.test_templates.test_email_template_renders_recipients_and_fixed_versions", + "eval.tests.test_templates.test_export_file_permissions_0600", + "eval.tests.test_templates.test_export_invalid_format_keeps_loop", + "eval.tests.test_templates.test_fresh_state_status_notes_missing_file", + "eval.tests.test_templates.test_issue_omits_cvss_block_when_no_cvss", + "eval.tests.test_templates.test_issue_template_renders_cvedata_fields", + "eval.tests.test_templates.test_restore_validates_steps_from_file", + "eval.tests.test_templates.test_save_then_export_round_trip", + "eval.tests.test_templates.test_slack_omits_component_when_no_versions", + "eval.tests.test_templates.test_slack_template_renders_component_and_summary", + "eval.tests.test_templates.test_uppercase_e_is_still_invalid_export_format", + "eval.tests.test_templates.test_uppercase_export_key_lowercased" + ] + } + }, + "commit": "e7f5f07ba369ca8c26a45ed5b8606b96fb76aeea", + "data_source": "synthetic_programgym", + "difficulty": "", + "difficulty_score": null, + "eval_clean_hashes": [ + "c1c6dba511fba7fb4e273ef714e6896d1da62c4f0b1685510b014a85d4f2799c" + ], + "input_record": { + "commit": "e7f5f07ba369ca8c26a45ed5b8606b96fb76aeea", + "commits": 246, + "contributors": 36, + "difficulty": "easy", + "difficulty_code_lines": 1749, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 1749, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.2427898094786767, + "difficulty_test_code_lines": 1645, + "full_name": "kubernetes/sig-security", + "github_stars": 249, + "input_joern_zip": "go_joern/kubernetes__sig-security.zip", + "joern_status": true, + "joern_time": 10.304412194993347, + "language": "go", + "pb_match": [ + { + "pb_fullname": "segmentio/chamber", + "rank": 451, + "similarity": 0.5214689373970032 + } + ], + "repo_age": 4.89, + "repo_path": "go/kubernetes__sig-security", + "source": "commit:e7f5f07ba369ca8c26a45ed5b8606b96fb76aeea", + "status": "done", + "url": "https://github.com/kubernetes/sig-security" + }, + "instance_id": "kubernetes__sig-security.e7f5f07", + "language": "go", + "module_iterations": [], + "repository": "kubernetes/sig-security" +} diff --git a/kubernetes--sig-security.e7f5f07/tests/test.sh b/kubernetes--sig-security.e7f5f07/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kubernetes--sig-security.e7f5f07/tests/workspace.tar.gz b/kubernetes--sig-security.e7f5f07/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..232b7e8b963f8d000af41f162e9a038b1ede923e --- /dev/null +++ b/kubernetes--sig-security.e7f5f07/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2008e3275b8fc516da8025442e0026258a41a320535be70a36b851ef2af2b961 +size 2075 diff --git a/kudrykv--latex-yearly-planner.c4/environment/Dockerfile b/kudrykv--latex-yearly-planner.c4/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kudrykv--latex-yearly-planner.c4/environment/download.sh b/kudrykv--latex-yearly-planner.c4/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..debfbb9be7234bf7b615b717b3160f2c8c02ee15 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/environment/download.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kudrykv/latex-yearly-planner + +go 1.16 + +require ( + github.com/caarlos0/env/v6 v6.7.0 + github.com/urfave/cli/v2 v2.3.0 + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/caarlos0/env/v6 v6.7.0 h1:OftrMgQyETinUI4YU3WxhHeKtCRonDMtnUO14+ZRXdY= +github.com/caarlos0/env/v6 v6.7.0/go.mod h1:FE0jGiAnQqtv2TenJ4KTa8+/T2Ss8kdS5s1VEjasoN0= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/urfave/cli/v2 v2.3.0 h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M= +github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +PROGRAMGYM_GO_SUM_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kudrykv--latex-yearly-planner.c4/environment/executable b/kudrykv--latex-yearly-planner.c4/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..ec8157953df04338a1f440125526aa3bacaee8c2 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:317e7b28e09393fc282933277ce925e325dd92e0983d07541dd489db9664cfd7 +size 6576676 diff --git a/kudrykv--latex-yearly-planner.c4/environment/programgym-go.tar.gz b/kudrykv--latex-yearly-planner.c4/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kudrykv--latex-yearly-planner.c4/environment/workspace.tar.gz b/kudrykv--latex-yearly-planner.c4/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..228376197899c3e57710c34506ba1492a7fc306e --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:21140719cdc545090ce27ac7b0782f3125e94b1b24cf24e8abc17ffa529f1a44 +size 10171 diff --git a/kudrykv--latex-yearly-planner.c4/instruction.md b/kudrykv--latex-yearly-planner.c4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kudrykv--latex-yearly-planner.c4/solution/solve.sh b/kudrykv--latex-yearly-planner.c4/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kudrykv--latex-yearly-planner.c4/task.toml b/kudrykv--latex-yearly-planner.c4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c2840d7bf06ce090f604bf82ae3477412bacbdab --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kudrykv--latex-yearly-planner.c4" +description = "Synthetic ProgramGym cleanroom reconstruction task for kudrykv/latex-yearly-planner" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kudrykv__latex-yearly-planner.c4e49d3" +repository = "kudrykv/latex-yearly-planner" +commit = "c4e49d3c1657876a8cea82e26dce2c611d60b2eb" +language = "go" +difficulty = "easy" +difficulty_score = 1.9546283775072713 +test_branches = 4 +test_count = 417 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kudrykv--latex-yearly-planner.c4/tests/Dockerfile b/kudrykv--latex-yearly-planner.c4/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_01.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..542257ce03b2808019e8a1ac7a6018f6793cd1ad --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e2d63a201bf202dcd25a19bc294623c8d94360d619827d1ab518d89ce47d193 +size 26253 diff --git a/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_02.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8212e0b2acde585d7a5c8aaa8120bd3076184280 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e135f6fb5c98f3a308e95a91705f2234d14fa1f39d127be7118664a5365e142e +size 19525 diff --git a/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_03.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1f0095f2f26ab19a2289d56ef1f20211bdaf1cc7 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5781e66a95c17e76eaad04fa273309182fd231c08032823e4f93f64a44be5941 +size 29229 diff --git a/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_04.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e096308e55e4a4f477e36956bbb433e99d23a51b --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cbfef7001ea6e50656aef820f6d5b7120a7072c3f42f0bfae27f88d5356b205 +size 13719 diff --git a/kudrykv--latex-yearly-planner.c4/tests/download.sh b/kudrykv--latex-yearly-planner.c4/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..debfbb9be7234bf7b615b717b3160f2c8c02ee15 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/download.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kudrykv/latex-yearly-planner + +go 1.16 + +require ( + github.com/caarlos0/env/v6 v6.7.0 + github.com/urfave/cli/v2 v2.3.0 + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/caarlos0/env/v6 v6.7.0 h1:OftrMgQyETinUI4YU3WxhHeKtCRonDMtnUO14+ZRXdY= +github.com/caarlos0/env/v6 v6.7.0/go.mod h1:FE0jGiAnQqtv2TenJ4KTa8+/T2Ss8kdS5s1VEjasoN0= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/urfave/cli/v2 v2.3.0 h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M= +github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +PROGRAMGYM_GO_SUM_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +if ! (cd /workspace/.programgym_build_env/go-prefetch && go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kudrykv--latex-yearly-planner.c4/tests/executable b/kudrykv--latex-yearly-planner.c4/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..ec8157953df04338a1f440125526aa3bacaee8c2 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:317e7b28e09393fc282933277ce925e325dd92e0983d07541dd489db9664cfd7 +size 6576676 diff --git a/kudrykv--latex-yearly-planner.c4/tests/programgym-go.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kudrykv--latex-yearly-planner.c4/tests/programgym_evaluator.py b/kudrykv--latex-yearly-planner.c4/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kudrykv--latex-yearly-planner.c4/tests/programgym_task.json b/kudrykv--latex-yearly-planner.c4/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..b098ed9c9caa218fa73150c793777926cab9509d --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/programgym_task.json @@ -0,0 +1,573 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_config_daily_composer_fields.TestAMPMTime.test_ampmtime_afternoon_maps_13_to_1pm", + "eval.tests.test_config_daily_composer_fields.TestAMPMTime.test_ampmtime_false_renders_24h_plain_cells", + "eval.tests.test_config_daily_composer_fields.TestAMPMTime.test_ampmtime_true_renders_12h_parbox_cells", + "eval.tests.test_config_daily_composer_fields.TestAddLastHalfHour.test_addlasthalfhour_false_omits_vbox", + "eval.tests.test_config_daily_composer_fields.TestAddLastHalfHour.test_addlasthalfhour_true_adds_vbox_per_day", + "eval.tests.test_config_daily_composer_fields.TestCalAfterSchedule.test_calafterschedule_false_omits_month_tabular", + "eval.tests.test_config_daily_composer_fields.TestCalAfterSchedule.test_calafterschedule_true_embeds_month_tabular", + "eval.tests.test_config_daily_composer_fields.TestDailyComposerFieldCombinations.test_ampm_and_halfhour_combine_independently", + "eval.tests.test_config_daily_composer_fields.TestDailyComposerFieldCombinations.test_cal_bool_does_not_touch_hour_cells", + "eval.tests.test_config_daily_composer_fields.TestDailyComposerFieldCombinations.test_calendar_weekday_header_tracks_weekstart[monday_start]", + "eval.tests.test_config_daily_composer_fields.TestDailyComposerFieldCombinations.test_calendar_weekday_header_tracks_weekstart[sunday_start]", + "eval.tests.test_config_daily_composer_fields.TestDailyComposerFieldCombinations.test_calendar_weekday_header_tracks_weekstart[tuesday_start]", + "eval.tests.test_config_env.TestEnvPaper.test_env_margins_mix_with_config", + "eval.tests.test_config_env.TestEnvPaper.test_env_paper_margins_override", + "eval.tests.test_config_env.TestEnvPaper.test_env_paper_width_alone_overrides_width", + "eval.tests.test_config_env.TestEnvPaper.test_env_paper_width_height_override", + "eval.tests.test_config_env.TestEnvPaper.test_env_paper_width_provides_absent_yaml_width", + "eval.tests.test_config_env.TestEnvParseError.test_invalid_margin_env", + "eval.tests.test_config_env.TestEnvParseError.test_invalid_year_env", + "eval.tests.test_config_env.TestEnvYear.test_config_year_used_without_env", + "eval.tests.test_config_env.TestEnvYear.test_env_year_affects_calendar_grids", + "eval.tests.test_config_env.TestEnvYear.test_env_year_overrides_absent_year", + "eval.tests.test_config_env.TestEnvYear.test_env_year_overrides_config_year", + "eval.tests.test_config_fields.TestBooleanConfig.test_debug_showframe_adds_usepackage", + "eval.tests.test_config_fields.TestBooleanConfig.test_debug_showframe_false_omits_usepackage", + "eval.tests.test_config_fields.TestBooleanConfig.test_debug_showlinks_default_keeps_hidelinks", + "eval.tests.test_config_fields.TestBooleanConfig.test_debug_showlinks_removes_hidelinks", + "eval.tests.test_config_fields.TestBooleanConfig.test_dotted_false_uses_lines", + "eval.tests.test_config_fields.TestBooleanConfig.test_dotted_true_uses_dotgrid", + "eval.tests.test_config_fields.TestLayoutColors.test_gray_colors_rendered", + "eval.tests.test_config_fields.TestLayoutLengths.test_lengthline_rendered", + "eval.tests.test_config_fields.TestLayoutLengths.test_special_latex_escape_preserved", + "eval.tests.test_config_fields.TestLayoutLengths.test_spring_commands_rendered", + "eval.tests.test_config_fields.TestLayoutLengths.test_tabcolsep_rendered", + "eval.tests.test_config_fields.TestLayoutNumbers.test_arraystretch_rendered", + "eval.tests.test_config_fields.TestLayoutNumbers.test_multiple_numbers_together", + "eval.tests.test_config_fields.TestLayoutNumbers.test_quarterly_lines_rendered", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightDefault.test_default_omits_custom_value", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightDefault.test_empty_string_is_explicitly_accepted", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_dimension_value_observed", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_value_renders_in_each_page_type[annual]", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_value_renders_in_each_page_type[daily]", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_value_renders_in_each_page_type[monthly]", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_value_renders_in_each_page_type[quarterly]", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_custom_value_renders_in_each_page_type[weekly]", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightPropagation.test_monthly_total_occurrences_equal_table_slots", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightVerbatim.test_daily_slot_count_depends_on_year_length", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightVerbatim.test_latex_dim_expression_passed_through_raw", + "eval.tests.test_config_header_side_cell_height.TestHeaderSideCellHeightVerbatim.test_no_shared_mylen_macro_is_emitted", + "eval.tests.test_config_hour_window_edges.TestFullDayWindow.test_ampm_false_full_day_zero_padded_and_total", + "eval.tests.test_config_hour_window_edges.TestFullDayWindow.test_ampm_true_full_day_noon_and_midnight_coexist", + "eval.tests.test_config_hour_window_edges.TestInvertedWindowError.test_inverted_hour_window_fails[afternoon_inverted]", + "eval.tests.test_config_hour_window_edges.TestInvertedWindowError.test_inverted_hour_window_fails[late_night_inverted]", + "eval.tests.test_config_hour_window_edges.TestInvertedWindowError.test_inverted_hour_window_fails[pre_midnight_inverted]", + "eval.tests.test_config_hour_window_edges.TestMidnightAMPM.test_ampm_false_midnight_zero_padded", + "eval.tests.test_config_hour_window_edges.TestMidnightAMPM.test_ampm_true_midnight_00_02", + "eval.tests.test_config_hour_window_edges.TestNoonBoundaryAMPM.test_ampm_false_no_am_pm_at_noon_window", + "eval.tests.test_config_hour_window_edges.TestNoonBoundaryAMPM.test_ampm_true_noon_boundary_11_13", + "eval.tests.test_config_hour_window_edges.TestSingleHourWindow.test_single_hour_window_12h_renders_plain_label", + "eval.tests.test_config_hour_window_edges.TestSingleHourWindow.test_single_hour_window_24h_renders_zero_padded_hour", + "eval.tests.test_config_hour_window_edges.TestWindowIndependentComposerFields.test_addlasthalfhour_gutter_holds_in_morning_window", + "eval.tests.test_config_hour_window_edges.TestWindowIndependentComposerFields.test_calafterschedule_calendar_holds_in_morning_window", + "eval.tests.test_config_hour_window_edges.TestWindowIndependentComposerFields.test_morning_ampm_calendar_and_halfhour_together", + "eval.tests.test_config_layout_behavior.TestClearTopRightCorner.test_cleartoprightcorner_false_omits_kern_cell", + "eval.tests.test_config_layout_behavior.TestClearTopRightCorner.test_cleartoprightcorner_true_adds_kern_cell", + "eval.tests.test_config_layout_behavior.TestNotesIndexNumbers.test_more_notes_index_pages_adds_second_index_marker", + "eval.tests.test_config_layout_behavior.TestNotesIndexNumbers.test_more_notes_on_page_increases_note_cells", + "eval.tests.test_config_layout_behavior.TestNotesIndexNumbers.test_notes_index_total_pages_tracked", + "eval.tests.test_config_layout_behavior.TestNotesIndexNumbers.test_zero_notes_numbers_yield_empty_index_page", + "eval.tests.test_config_layout_behavior.TestWeekStart.test_weekstart_changes_alignment_of_first_week_cells", + "eval.tests.test_config_layout_behavior.TestWeekStart.test_weekstart_reorders_month_weekday_header[0]", + "eval.tests.test_config_layout_behavior.TestWeekStart.test_weekstart_reorders_month_weekday_header[1]", + "eval.tests.test_config_layout_behavior.TestWeekStart.test_weekstart_reorders_month_weekday_header[2]", + "eval.tests.test_config_layout_behavior.TestWeekStart.test_weekstart_reorders_month_weekday_header[6]", + "eval.tests.test_config_layout_fields.TestAllLengthsFields.test_all_lengths_render_with_pt_values", + "eval.tests.test_config_layout_fields.TestAllLengthsFields.test_five_col_sep_specific", + "eval.tests.test_config_layout_fields.TestAllLengthsFields.test_length_with_cm_unit", + "eval.tests.test_config_layout_fields.TestAllLengthsFields.test_length_with_dimexpr_expression", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_all_numbers_render_individually", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_arraystretch_float_value", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_daily_bottom_hour_large", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_daily_top_hour_large", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_dot_width_full", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_dot_width_two_thirds", + "eval.tests.test_config_layout_fields.TestAllNumbersFields.test_quarterly_lines_boundary", + "eval.tests.test_config_layout_fields.TestEmptyAndMinimalConfig.test_comment_only_config", + "eval.tests.test_config_layout_fields.TestEmptyAndMinimalConfig.test_empty_config_file", + "eval.tests.test_config_layout_fields.TestEmptyAndMinimalConfig.test_whitespace_only_config", + "eval.tests.test_config_layout_fields.TestSpringAndColors.test_all_springs_render", + "eval.tests.test_config_layout_fields.TestSpringAndColors.test_colors_render", + "eval.tests.test_config_output.TestOutputIOErrors.test_missing_out_directory", + "eval.tests.test_config_output.TestRootFilename.test_nested_path_directory_stripped", + "eval.tests.test_config_output.TestRootFilename.test_no_extension_uses_whole_basename", + "eval.tests.test_config_output.TestRootFilename.test_yaml_extension_stripped", + "eval.tests.test_config_output.TestRootFilename.test_yml_extension_stripped", + "eval.tests.test_config_output.TestWeeklyPage.test_daily_funcname_renders_daily_file", + "eval.tests.test_config_output.TestWeeklyPage.test_weekly_funcname_renders_weekly_file", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[annual]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[daily]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[daily_notes]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[daily_reflect]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[monthly]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[quarterly]", + "eval.tests.test_config_pages.TestComposerDispatch.test_composer_funcname_renders_page[weekly]", + "eval.tests.test_config_pages.TestPageFileGeneration.test_document_includes_each_page", + "eval.tests.test_config_pages.TestPageFileGeneration.test_multiple_pages_each_generate_file", + "eval.tests.test_config_pages.TestPageFileGeneration.test_page_name_creates_page_file", + "eval.tests.test_config_pages.TestPageFileGeneration.test_renderblock_tpls_selection", + "eval.tests.test_config_pages.TestRenderBlocks.test_empty_renderblocks_errors", + "eval.tests.test_config_pages.TestRenderBlocks.test_no_pages_field_succeeds", + "eval.tests.test_config_pages.TestRenderBlocks.test_unknown_funcname_errors", + "eval.tests.test_config_parse.TestConfigErrors.test_bare_scalar_document", + "eval.tests.test_config_parse.TestConfigErrors.test_boolean_field_with_string_value", + "eval.tests.test_config_parse.TestConfigErrors.test_config_path_is_directory", + "eval.tests.test_config_parse.TestConfigErrors.test_layout_field_as_scalar", + "eval.tests.test_config_parse.TestConfigErrors.test_malformed_yaml", + "eval.tests.test_config_parse.TestConfigErrors.test_malformed_yaml_scalar_type", + "eval.tests.test_config_parse.TestConfigErrors.test_missing_config_file", + "eval.tests.test_config_parse.TestConfigErrors.test_missing_second_config_after_valid_first", + "eval.tests.test_config_parse.TestConfigErrors.test_numeric_field_with_string_value", + "eval.tests.test_config_parse.TestMultiConfigMerge.test_later_config_overrides_margin", + "eval.tests.test_config_parse.TestMultiConfigMerge.test_later_config_overrides_width", + "eval.tests.test_config_parse.TestMultiConfigMerge.test_three_config_chain", + "eval.tests.test_config_parse.TestPathLowercasing.test_uppercase_only_filename_not_found", + "eval.tests.test_config_parse.TestPathLowercasing.test_uppercase_path_is_lowercased", + "eval.tests.test_config_parse.TestSingleConfigParse.test_marginpar_width_and_sep_rendered", + "eval.tests.test_config_parse.TestSingleConfigParse.test_reverse_margins_emitted", + "eval.tests.test_config_parse.TestSingleConfigParse.test_reverse_margins_false_omitted", + "eval.tests.test_config_parse.TestSingleConfigParse.test_valid_config_margins_rendered", + "eval.tests.test_config_parse.TestSingleConfigParse.test_valid_config_renders_paper_geometry", + "eval.tests.test_config_year.TestYearDefaulting.test_explicit_year_not_overridden", + "eval.tests.test_config_year.TestYearDefaulting.test_missing_year_default_differs_from_explicit_sentinel", + "eval.tests.test_config_year.TestYearDefaulting.test_missing_year_defaults_to_deterministic_year", + "eval.tests.test_config_year.TestYearDefaulting.test_zero_year_defaults_to_deterministic_year" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_annual_compose.test_annual_century_boundary_years", + "eval.tests.test_annual_compose.test_annual_is_a_single_page", + "eval.tests.test_annual_compose.test_annual_links_every_day_of_year", + "eval.tests.test_annual_compose.test_annual_links_first_day_of_year", + "eval.tests.test_annual_compose.test_annual_lists_each_month_once", + "eval.tests.test_annual_compose.test_annual_non_leap_year_no_feb29", + "eval.tests.test_annual_compose.test_annual_references_notes_index", + "eval.tests.test_annual_compose.test_annual_renders_all_twelve_months", + "eval.tests.test_annual_compose.test_annual_renders_only_own_year_dates", + "eval.tests.test_annual_compose.test_annual_renders_quarter_links", + "eval.tests.test_cli_reachability.test_empty_renderblocks_rejected", + "eval.tests.test_cli_reachability.test_help_flag_lists_flags", + "eval.tests.test_cli_reachability.test_malformed_yaml_rejected", + "eval.tests.test_cli_reachability.test_missing_config_flag_errors", + "eval.tests.test_cli_reachability.test_no_args_run_in_clear_workdir_shows_help_and_error", + "eval.tests.test_cli_reachability.test_nonexistent_config_path_errors", + "eval.tests.test_cli_reachability.test_referenced_template_missing_rejected", + "eval.tests.test_cli_reachability.test_short_h_flag", + "eval.tests.test_cli_reachability.test_unknown_composer_function_rejected", + "eval.tests.test_config_alignment.test_clear_top_right_corner_adds_header_blank", + "eval.tests.test_config_alignment.test_each_page_produces_its_own_tex_file", + "eval.tests.test_config_alignment.test_later_config_page_name_wins_on_merge", + "eval.tests.test_config_alignment.test_multiple_configs_merge_disjoint_fields", + "eval.tests.test_config_alignment.test_planner_year_env_overrides_config_year", + "eval.tests.test_config_alignment.test_planner_year_env_supplies_year_when_absent", + "eval.tests.test_config_alignment.test_root_filename_is_last_config_basename", + "eval.tests.test_config_alignment.test_title_renders_config_year", + "eval.tests.test_config_alignment.test_unaligned_render_blocks_rejected", + "eval.tests.test_config_alignment.test_yaml_extension_stripped_from_root_name", + "eval.tests.test_config_alignment.test_yml_extension_stripped_from_root_name", + "eval.tests.test_daily_compose.test_daily_covers_every_day_of_year", + "eval.tests.test_daily_compose.test_daily_has_per_day_pagebreak", + "eval.tests.test_daily_compose.test_daily_leap_year_includes_feb29", + "eval.tests.test_daily_compose.test_daily_non_leap_year_excludes_feb29", + "eval.tests.test_daily_compose.test_daily_notes_breadcrumb_prefix", + "eval.tests.test_daily_compose.test_daily_notes_emits_more_and_notes_headers", + "eval.tests.test_daily_compose.test_daily_pagebreak_count_matches_days_in_year", + "eval.tests.test_daily_compose.test_daily_prev_next_day_links", + "eval.tests.test_daily_compose.test_daily_reflect_breadcrumb_prefix", + "eval.tests.test_daily_compose.test_daily_reflect_emits_reflect_header", + "eval.tests.test_daily_compose.test_daily_variants_differ_in_output", + "eval.tests.test_daily_compose.test_dotted_flag_toggles_note_body_texture", + "eval.tests.test_daily_compose.test_plain_daily_breadcrumb_no_prefix", + "eval.tests.test_daily_compose.test_plain_daily_lacks_reflect_sections", + "eval.tests.test_layout_flags.test_addlasthalfhour_adds_trailing_line", + "eval.tests.test_layout_flags.test_addlasthalfhour_off_has_no_trailing_line", + "eval.tests.test_layout_flags.test_all_three_layout_flags_compose", + "eval.tests.test_layout_flags.test_ampmtime_default_is_false", + "eval.tests.test_layout_flags.test_ampmtime_flips_schedule_to_12h", + "eval.tests.test_layout_flags.test_calafterschedule_appends_calendar_table", + "eval.tests.test_layout_flags.test_calafterschedule_off_no_calendar_table", + "eval.tests.test_layout_flags.test_debug_both_flags_accepted", + "eval.tests.test_layout_flags.test_debug_showframe_accepted", + "eval.tests.test_layout_flags.test_debug_showlinks_accepted", + "eval.tests.test_layout_flags.test_default_schedule_uses_24h_minute_cells", + "eval.tests.test_layout_flags.test_numbered_layout_affects_notes_index_volume", + "eval.tests.test_layout_flags.test_numbers_config_sets_daily_macros", + "eval.tests.test_layout_flags.test_numbers_default_to_zero", + "eval.tests.test_monthly_compose.test_monthly_december_ends_with_dec_31", + "eval.tests.test_monthly_compose.test_monthly_feb_leap_year_has_29_days", + "eval.tests.test_monthly_compose.test_monthly_has_twelve_or_more_pages", + "eval.tests.test_monthly_compose.test_monthly_january_grid_starts_at_jan_1", + "eval.tests.test_monthly_compose.test_monthly_names_all_twelve_months", + "eval.tests.test_monthly_compose.test_monthly_non_leap_feb_lacks_29", + "eval.tests.test_monthly_compose.test_monthly_pagebreak_count_is_twelve", + "eval.tests.test_monthly_compose.test_monthly_prev_next_navigation_present", + "eval.tests.test_monthly_compose.test_monthly_twelve_month_series_shares_navigable_neighbours", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_default_config_emits_empty", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_note_pages_named_by_number", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_notes_count_matches_product", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_produces_expected_note_links", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_single_page_single_note", + "eval.tests.test_notes_indexed_compose.test_notes_indexed_writes_larger_output_with_more_pages", + "eval.tests.test_preview_volume.test_full_daily_is_large_preview_is_small", + "eval.tests.test_preview_volume.test_preview_collapses_daily_to_one_page", + "eval.tests.test_preview_volume.test_preview_dedups_multi_template_composer_by_template", + "eval.tests.test_preview_volume.test_preview_still_emits_pages", + "eval.tests.test_preview_volume.test_quarterly_vs_daily_module_volume", + "eval.tests.test_quarterly_compose.test_quarterly_emits_four_pages", + "eval.tests.test_quarterly_compose.test_quarterly_first_quarter_dates", + "eval.tests.test_quarterly_compose.test_quarterly_mentions_every_month", + "eval.tests.test_quarterly_compose.test_quarterly_names_all_quarters", + "eval.tests.test_quarterly_compose.test_quarterly_pagebreak_count_is_four", + "eval.tests.test_quarterly_compose.test_quarterly_q4_reaches_december", + "eval.tests.test_quarterly_compose.test_quarterly_renders_notes_index_link", + "eval.tests.test_title_compose.test_title_produces_single_tiny_page", + "eval.tests.test_title_compose.test_title_rejects_multiple_templates", + "eval.tests.test_title_compose.test_title_rejects_three_templates", + "eval.tests.test_title_compose.test_title_rejects_zero_templates", + "eval.tests.test_title_compose.test_title_renders_four_digit_year_in_resizebox", + "eval.tests.test_title_compose.test_title_template_count_error_goes_to_stdout_only", + "eval.tests.test_title_compose.test_title_template_count_error_withholds_page_output", + "eval.tests.test_title_compose.test_title_variants_across_years_parametrized", + "eval.tests.test_weekly_compose.test_weekly_53_week_leap_year", + "eval.tests.test_weekly_compose.test_weekly_53_week_year_pagebreak_count", + "eval.tests.test_weekly_compose.test_weekly_contains_week_links", + "eval.tests.test_weekly_compose.test_weekly_has_many_week_pagebreaks", + "eval.tests.test_weekly_compose.test_weekly_pagebreak_volume_is_stable_across_week_counts", + "eval.tests.test_weekly_compose.test_weekly_regular_year_no_week_53", + "eval.tests.test_weekly_compose.test_weekly_weekstart_changes_first_anchor", + "eval.tests.test_weekly_compose.test_weekly_weekstart_monday_leads_first_page", + "eval.tests.test_weekly_compose.test_weekly_weekstart_sunday_leads_first_page", + "eval.tests.test_weekly_compose.test_weekly_weekstart_unset_defaults_to_sunday" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_annual.test_annual_heading_resize_wrapped", + "eval.tests.test_annual.test_annual_heading_uses_given_year[common]", + "eval.tests.test_annual.test_annual_heading_uses_given_year[future]", + "eval.tests.test_annual.test_annual_heading_uses_given_year[leap]", + "eval.tests.test_annual.test_annual_not_wrapped_in_year_int_item", + "eval.tests.test_annual.test_annual_notes_extra_link", + "eval.tests.test_annual.test_annual_renders_four_quarters", + "eval.tests.test_annual.test_annual_year_renderable_on_title_like_resize", + "eval.tests.test_annual.test_annual_yielded_twelve_side_month_names", + "eval.tests.test_cellitem_header.test_calendar_cell_selected_with_default_ref", + "eval.tests.test_cellitem_header.test_notes_cell_explicit_ref_and_unselected", + "eval.tests.test_cellitem_header.test_with_corner_enabled_appends_kern_cell", + "eval.tests.test_cellitem_header.test_without_corner_row_ends_at_notes", + "eval.tests.test_cli.test_empty_config_still_writes_root_file", + "eval.tests.test_cli.test_help_flag_lists_options[long]", + "eval.tests.test_cli.test_help_flag_lists_options[short]", + "eval.tests.test_cli.test_malformed_yaml_config_errors", + "eval.tests.test_cli.test_missing_config_required_flag_fails", + "eval.tests.test_cli.test_nonexistent_config_file_errors", + "eval.tests.test_cli.test_run_from_dir_without_tpls_panics", + "eval.tests.test_cli.test_undefined_long_flag_rejected", + "eval.tests.test_cli.test_unknown_flag_rejected", + "eval.tests.test_cli.test_year_defaults_to_current_year", + "eval.tests.test_cli.test_year_from_planner_year_env", + "eval.tests.test_config_io.test_clear_top_right_corner_changes_extra_cell", + "eval.tests.test_config_io.test_comma_joined_configs_merge", + "eval.tests.test_config_io.test_dotted_layout_changes_notes_body[dotted]", + "eval.tests.test_config_io.test_dotted_layout_changes_notes_body[lined]", + "eval.tests.test_config_io.test_full_generation_produces_all_pages", + "eval.tests.test_config_io.test_preview_collapses_daily_modules", + "eval.tests.test_config_io.test_preview_keeps_other_pages_intact", + "eval.tests.test_config_io.test_root_document_written", + "eval.tests.test_config_io.test_root_filename_uses_last_config_basename", + "eval.tests.test_config_io.test_yaml_extension_stripped_from_root_name", + "eval.tests.test_daily_variants.test_daily_notes_heading_anchor_uses_more_prefix", + "eval.tests.test_daily_variants.test_daily_notes_nav_arrows_use_more_prefix", + "eval.tests.test_daily_variants.test_daily_reflect_heading_anchor_uses_reflect_prefix", + "eval.tests.test_daily_variants.test_daily_reflect_nav_arrows_use_reflect_prefix", + "eval.tests.test_daily_variants.test_plain_daily_does_not_link_day_number", + "eval.tests.test_daily_variants.test_reflect_notes_day_number_hyperlinks_own_ref", + "eval.tests.test_daily_variants.test_two_variants_prefixed_refs_cover_every_date", + "eval.tests.test_day.test_ampm_hour_bounds", + "eval.tests.test_day.test_annual_has_365_day_cells", + "eval.tests.test_day.test_daily_all_notes_link", + "eval.tests.test_day.test_daily_hours_range_bottom_to_top", + "eval.tests.test_day.test_daily_leaf_links_more_and_reflect", + "eval.tests.test_day.test_day_cell_is_rfc3339_hyperlink", + "eval.tests.test_day.test_day_emphasis_appears_with_cal_after_schedule", + "eval.tests.test_day.test_day_hour_format_honors_ampm[24h]", + "eval.tests.test_day.test_day_hour_format_honors_ampm[ampm]", + "eval.tests.test_day.test_january_month_has_31_day_cells", + "eval.tests.test_day.test_leap_year_has_366_day_cells", + "eval.tests.test_day.test_no_today_highlight_without_cal_in_daily", + "eval.tests.test_headingmos.test_daily_first_day_header_has_next_but_no_prev", + "eval.tests.test_headingmos.test_daily_heading_bolds_weekday_and_month", + "eval.tests.test_headingmos.test_daily_last_day_header_has_prev_but_no_next", + "eval.tests.test_headingmos.test_daily_middle_day_header_has_both_nav_columns", + "eval.tests.test_headingmos.test_daily_nav_arrows_total_edges", + "eval.tests.test_headingmos.test_month_heading_mos_adds_dummy_suffix", + "eval.tests.test_headingmos.test_note_heading_mos_dummy_suffix_each_note", + "eval.tests.test_headingmos.test_notes_index_heading_paginates_edges", + "eval.tests.test_headingmos.test_quarter_heading_mos_resizebox_wrap", + "eval.tests.test_hyper_header.test_breadcrumb_corner_table_present", + "eval.tests.test_hyper_header.test_full_month_caption_also_present_in_small_grid", + "eval.tests.test_hyper_header.test_hyper_link_anchor_format", + "eval.tests.test_hyper_header.test_hyper_links_wrap_plain_text_only", + "eval.tests.test_hyper_header.test_hyper_target_anchor_format", + "eval.tests.test_hyper_header.test_month_breadcrumb_includes_year_and_quarter", + "eval.tests.test_hyper_header.test_month_short_name_is_three_letters", + "eval.tests.test_hyper_header.test_quarter_breadcrumb_q_entries", + "eval.tests.test_hyper_header.test_selected_month_shortname_highlighted", + "eval.tests.test_hyper_header.test_selected_quarter_highlighted", + "eval.tests.test_hyper_header.test_side_months_reversed_chronology", + "eval.tests.test_hyper_header.test_side_quarters_reversed_order", + "eval.tests.test_hyper_header.test_week_breadcrumb_contains_week_label", + "eval.tests.test_month.test_large_month_anchors_full_month_name", + "eval.tests.test_month.test_large_month_rotated_week_numbers", + "eval.tests.test_month.test_large_month_uses_tabularx_grid", + "eval.tests.test_month.test_large_week_header_full_weekday_names", + "eval.tests.test_month.test_month_grid_links_each_day_as_large_cell", + "eval.tests.test_month.test_month_short_name_three_letters", + "eval.tests.test_month.test_small_mode_prints_month_multicol_caption", + "eval.tests.test_month.test_small_month_uses_plain_tabular", + "eval.tests.test_month.test_small_week_header_row_of_letters", + "eval.tests.test_month_weekheader.test_large_grid_full_weekday_header", + "eval.tests.test_month_weekheader.test_small_grid_letter_header_shape", + "eval.tests.test_monthitem.test_month_item_ref_full_name_hypertarget", + "eval.tests.test_monthitem.test_month_item_shorten_three_letter_link", + "eval.tests.test_notes.test_double_digit_note_not_zero_padded", + "eval.tests.test_notes.test_note_heading_targets_each_note", + "eval.tests.test_notes.test_note_hyperlink_is_zero_padded", + "eval.tests.test_notes.test_notes_index_page_targets", + "eval.tests.test_notes.test_notes_index_paginated_navigation", + "eval.tests.test_notes.test_notes_on_first_index_page_counts", + "eval.tests.test_notes.test_notes_scale_with_layout_numbers", + "eval.tests.test_notes.test_total_notes_from_layout_numbers", + "eval.tests.test_quarter.test_four_quarterly_pages_in_breadcrumb", + "eval.tests.test_quarter.test_quarter_heading_target[q1]", + "eval.tests.test_quarter.test_quarter_heading_target[q2]", + "eval.tests.test_quarter.test_quarter_heading_target[q3]", + "eval.tests.test_quarter.test_quarter_heading_target[q4]", + "eval.tests.test_quarter.test_quarter_name_is_q_plus_number", + "eval.tests.test_quarter.test_quarterly_page_contains_three_months", + "eval.tests.test_quarter.test_quarterly_uses_small_plain_tabular_for_months", + "eval.tests.test_week.test_fw_prefix_on_year_boundary_week[2021-week53]", + "eval.tests.test_week.test_fw_prefix_on_year_boundary_week[2023-week52]", + "eval.tests.test_week.test_iso_week_count_of_year[2024-52wk]", + "eval.tests.test_week.test_iso_week_count_of_year[2025-52wk]", + "eval.tests.test_week.test_iso_week_count_of_year[2026-53wk]", + "eval.tests.test_week.test_iso_week_count_of_year[2027-53wk]", + "eval.tests.test_week.test_no_fw_prefix_in_steady_year", + "eval.tests.test_week.test_week_links_cover_weeks_one_to_53", + "eval.tests.test_week.test_week_nav_prev_next_present", + "eval.tests.test_week.test_week_number_matches_link_text", + "eval.tests.test_week.test_week_target_hypertarget", + "eval.tests.test_weekly_page.test_dotted_weekly_uses_dot_mash_grid", + "eval.tests.test_weekly_page.test_lined_weekly_uses_ruled_lines", + "eval.tests.test_weekly_page.test_weeklink_cell_links_date_to_day_weekday", + "eval.tests.test_weekly_page.test_weeklink_covers_every_day_of_year", + "eval.tests.test_weekly_sidebar.test_weekly_sidebar_counts_spanning_months", + "eval.tests.test_weekly_sidebar.test_weekly_sidebar_counts_spanning_quarters", + "eval.tests.test_weekly_sidebar.test_weekly_sidebar_highlights_all_months", + "eval.tests.test_weekly_sidebar.test_weekly_sidebar_highlights_all_quarters" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_entry.test_config_flag_with_missing_value_errors", + "eval.tests.test_cli_entry.test_help_lists_required_config_and_preview_flags", + "eval.tests.test_cli_entry.test_help_prints_usage_and_exits_zero[--help]", + "eval.tests.test_cli_entry.test_help_prints_usage_and_exits_zero[-h]", + "eval.tests.test_cli_entry.test_help_subcommand_prints_usage_but_exits_one", + "eval.tests.test_cli_entry.test_no_arguments_fails_with_required_config", + "eval.tests.test_cli_entry.test_preview_flag_accepted_on_valid_config", + "eval.tests.test_cli_entry.test_unknown_flag_rejected", + "eval.tests.test_cli_entry.test_valid_single_config_succeeds_writes_output", + "eval.tests.test_config_loading.test_config_path_is_lowercased_for_read_but_rootname_keeps_case", + "eval.tests.test_config_loading.test_empty_config_produces_empty_document_and_no_pages", + "eval.tests.test_config_loading.test_malformed_yaml_fails_with_unmarshal_error", + "eval.tests.test_config_loading.test_missing_config_file_fails_with_read_error", + "eval.tests.test_config_loading.test_multiple_configs_last_path_wins_for_pages_and_doc_name", + "eval.tests.test_config_loading.test_paper_env_overrides_resurface_in_document[PLANNER_LAYOUT_PAPER_HEIGHT-888mm]", + "eval.tests.test_config_loading.test_paper_env_overrides_resurface_in_document[PLANNER_LAYOUT_PAPER_MARGIN_TOP-42mm]", + "eval.tests.test_config_loading.test_paper_env_overrides_resurface_in_document[PLANNER_LAYOUT_PAPER_WIDTH-999mm]", + "eval.tests.test_config_loading.test_planner_year_env_overrides_config_year", + "eval.tests.test_config_loading.test_wrong_type_for_weekday_fails", + "eval.tests.test_config_loading.test_yaml_paper_values_appear_in_document", + "eval.tests.test_config_loading.test_year_defaults_to_current_year_when_omitted", + "eval.tests.test_output_writing.test_config_without_extension_becomes_dot_tex", + "eval.tests.test_output_writing.test_document_filename_from_plain_yml", + "eval.tests.test_output_writing.test_document_filename_from_yaml_extension", + "eval.tests.test_output_writing.test_document_filename_keeps_uppercase_extension", + "eval.tests.test_output_writing.test_document_filename_uses_leaf_of_nested_path", + "eval.tests.test_output_writing.test_generated_files_use_owner_only_permissions", + "eval.tests.test_output_writing.test_missing_out_directory_fails_with_write_error", + "eval.tests.test_output_writing.test_output_written_only_for_configured_pages", + "eval.tests.test_output_writing.test_page_name_used_verbatim_as_output_basename", + "eval.tests.test_page_generation.test_aligned_multiple_render_blocks_render_one_page", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_annual-annual-tpls0]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_daily-daily-tpls4]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_dn-daily_notes-tpls6]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_dr-daily_reflect-tpls5]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_monthly-monthly-tpls2]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_quarterly-quarterly-tpls1]", + "eval.tests.test_page_generation.test_each_composer_produces_nonempty_page[p_weekly-weekly-tpls3]", + "eval.tests.test_page_generation.test_empty_renderblocks_errors", + "eval.tests.test_page_generation.test_full_2025_planner_generates_all_pages", + "eval.tests.test_page_generation.test_misaligned_render_blocks_are_rejected", + "eval.tests.test_page_generation.test_notes_indexed_renders_with_page_and_index_templates", + "eval.tests.test_page_generation.test_preview_deduplicates_for_weekly_daily", + "eval.tests.test_page_generation.test_preview_deduplicates_identical_modules_for_monthly", + "eval.tests.test_page_generation.test_preview_does_not_change_single_module_page", + "eval.tests.test_page_generation.test_title_page_embeds_configured_year", + "eval.tests.test_page_generation.test_title_rejects_wrong_tpl_count", + "eval.tests.test_page_generation.test_unknown_composer_is_rejected", + "eval.tests.test_template_runtime.test_document_default_hides_links", + "eval.tests.test_template_runtime.test_document_includes_each_page_by_name", + "eval.tests.test_template_runtime.test_document_reversemargins_flag", + "eval.tests.test_template_runtime.test_document_showframe_false_omits_package", + "eval.tests.test_template_runtime.test_document_showframe_true_adds_package", + "eval.tests.test_template_runtime.test_document_showlinks_true_omits_hidelinks", + "eval.tests.test_template_runtime.test_missing_tpls_directory_panics_at_startup", + "eval.tests.test_template_runtime.test_page_executes_saved_tex_helpers_when_used", + "eval.tests.test_template_runtime.test_schedule_template_included_in_document" + ] + } + }, + "commit": "c4e49d3c1657876a8cea82e26dce2c611d60b2eb", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.9546283775072713, + "eval_clean_hashes": [ + "317e7b28e09393fc282933277ce925e325dd92e0983d07541dd489db9664cfd7" + ], + "input_record": { + "commit": "c4e49d3c1657876a8cea82e26dce2c611d60b2eb", + "commits": 384, + "contributors": 11, + "difficulty": "easy", + "difficulty_code_lines": 2252, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 2252, + "difficulty_runtime_deps": 3, + "difficulty_score": 1.9546283775072713, + "difficulty_test_code_lines": 15, + "full_name": "kudrykv/latex-yearly-planner", + "github_stars": 1522, + "input_joern_zip": "go_joern/kudrykv__latex-yearly-planner.zip", + "joern_status": true, + "joern_time": 11.905126158846542, + "language": "go", + "pb_match": [ + { + "pb_fullname": "sclevine/yj", + "rank": 600, + "similarity": 0.4885745644569397 + }, + { + "pb_fullname": "antonmedv/walk", + "rank": 824, + "similarity": 0.4604300260543823 + }, + { + "pb_fullname": "johnkerl/miller", + "rank": 452, + "similarity": 0.4842033386230469 + }, + { + "pb_fullname": "JohannesKaufmann/html-to-markdown", + "rank": 140, + "similarity": 0.5317363739013672 + }, + { + "pb_fullname": "naggie/dstask", + "rank": 24, + "similarity": 0.6267588138580322 + }, + { + "pb_fullname": "noborus/ov", + "rank": 384, + "similarity": 0.5256224274635315 + }, + { + "pb_fullname": "sibprogrammer/xq", + "rank": 988, + "similarity": 0.46622246503829956 + }, + { + "pb_fullname": "TheZoraiz/ascii-image-converter", + "rank": 527, + "similarity": 0.48709726333618164 + }, + { + "pb_fullname": "cheat/cheat", + "rank": 381, + "similarity": 0.5257663726806641 + }, + { + "pb_fullname": "dundee/gdu", + "rank": 484, + "similarity": 0.5050769448280334 + }, + { + "pb_fullname": "zk-org/zk", + "rank": 18, + "similarity": 0.6726653575897217 + } + ], + "repo_age": 5.01, + "repo_path": "go/kudrykv__latex-yearly-planner", + "source": "commit:c4e49d3c1657876a8cea82e26dce2c611d60b2eb", + "status": "done", + "url": "https://github.com/kudrykv/latex-yearly-planner" + }, + "instance_id": "kudrykv__latex-yearly-planner.c4e49d3", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 2, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 4, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 1, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + } + ], + "repository": "kudrykv/latex-yearly-planner" +} diff --git a/kudrykv--latex-yearly-planner.c4/tests/test.sh b/kudrykv--latex-yearly-planner.c4/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kudrykv--latex-yearly-planner.c4/tests/workspace.tar.gz b/kudrykv--latex-yearly-planner.c4/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..228376197899c3e57710c34506ba1492a7fc306e --- /dev/null +++ b/kudrykv--latex-yearly-planner.c4/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:21140719cdc545090ce27ac7b0782f3125e94b1b24cf24e8abc17ffa529f1a44 +size 10171 diff --git a/kuvaus--llamagptj-chat.e022976/environment/Dockerfile b/kuvaus--llamagptj-chat.e022976/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kuvaus--llamagptj-chat.e022976/environment/docker-compose.yaml b/kuvaus--llamagptj-chat.e022976/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kuvaus--llamagptj-chat.e022976/environment/download.sh b/kuvaus--llamagptj-chat.e022976/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..4ba09fe4d26856d82d9a0c2c4bdf8f965fac8f4d --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/download.sh @@ -0,0 +1,147 @@ +#!/usr/bin/env bash +# +# ProgramGym download stage for kuvaus/LlamaGPTJ-chat. +# +# This script is intended to be SOURCED (`source /source_ro/download.sh`) at the +# repository root while the container still has network access. +# +# Its only job is to PRE-FETCH the git submodule source that this repository's +# build requires but that is NOT present in the checked-out tree: +# `gpt4all-backend/llama.cpp`. The root CMakeLists.txt does +# `add_subdirectory(gpt4all-backend/llama.cpp)`, and gpt4all-backend/CMakeLists.txt +# both links the `llama` target and compiles `llama.cpp/examples/common.cpp`. +# However the llama.cpp submodule is unpacked as an EMPTY directory in the +# checkout (only a `.gitmodules` pointer exists), so the submodule source must +# be provided separately. +# +# IMPORTANT: the validation stage mounts the source tree READ-ONLY at +# /source_ro, so this script must NOT write into the repository tree. Instead +# it downloads, verifies, and unpacks the pinned llama.cpp source archive into a +# separate writable cache directory under /tmp, and exports the path to it via +# $PB_LLAMA_CPP_DIR. The offline build stage (build.sh, running in the writable +# /workspace/source copy) then copies those sources into +# gpt4all-backend/llama.cpp/ itself. We therefore never touch ./git or +# ./gpt4all-backend here. +# +# No compilation, linking, testing, or packaging is performed here. + +# Sourced script guard: fail cleanly whether sourced or executed, using an +# explicit branch rather than a redirected return. +FAIL_DOWNLOAD() { + echo "download.sh: $1" >&2 +} + +# Submodule metadata (embedded explicitly; the download stage cannot read repo +# files, so the URL and checksum are pinned inline). +SUBMODULE_COMMIT="03ceb39c1e729bed4ad1dfa16638a72f1843bf0c" +SUBMODULE_URL="https://codeload.github.com/manyoso/llama.cpp/tar.gz/${SUBMODULE_COMMIT}" +SUBMODULE_SHA256="a02c16d8ae621c3551ab5ee616b16703df89f1c9edf7e03da7917197aa8767e4" + +# Writable staging area OUTSIDE the repository (repo mount is read-only during +# validation). /tmp persists within the build container between the download +# and the offline build stages. +PB_LLAMA_CPP_DIR="/tmp/programgym-llamagptj/llama.cpp-src" +export PB_LLAMA_CPP_DIR +STAGE_ROOT="/tmp/programgym-llamagptj" + +# Toolchain (cmake, make, gcc/g++ 13) is guaranteed by the base image; we only +# need a few archive/curl tools here. Sanity-check they exist. +MISSING_TOOL="" +for tool in curl tar gzip sha256sum mkdir rm; do + if ! command -v "$tool" >/dev/null; then + MISSING_TOOL="$MISSING_TOOL $tool" + fi +done +if [ -n "$MISSING_TOOL" ]; then + FAIL_DOWNLOAD "required tool(s) not found:$MISSING_TOOL" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi +unset MISSING_TOOL + +# Idempotency: if the staged llama.cpp source is already populated with the +# marker we wrote on a previous successful run, do nothing more. +if [ -f "${PB_LLAMA_CPP_DIR}/.programgym_extracted" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/CMakeLists.txt" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/llama.cpp" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/examples/common.cpp" ]; then + echo "download.sh: llama.cpp source already staged at ${PB_LLAMA_CPP_DIR}; skipping." + return 0 +fi + +# Create the staging root. +if ! mkdir -p "${STAGE_ROOT}" "${PB_LLAMA_CPP_DIR}"; then + FAIL_DOWNLOAD "failed to create staging dirs ${STAGE_ROOT} / ${PB_LLAMA_CPP_DIR}" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +TARBALL="${STAGE_ROOT}/llama.cpp.tar.gz" + +echo "download.sh: fetching llama.cpp submodule archive..." +if ! curl -fsSL --retry 3 -o "$TARBALL" "$SUBMODULE_URL"; then + FAIL_DOWNLOAD "failed to download $SUBMODULE_URL" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Integrity check so the offline build never sees a corrupted submodule tree. +echo "download.sh: verifying archive checksum..." +if ! echo "$SUBMODULE_SHA256 $TARBALL" | sha256sum -c -; then + FAIL_DOWNLOAD "checksum mismatch for $SUBMODULE_URL" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Unpack into the staging dir (replacing any stale/noop placeholder contents). +if [ -e "${PB_LLAMA_CPP_DIR}" ]; then + rm -rf "${PB_LLAMA_CPP_DIR}" +fi +if ! mkdir -p "${PB_LLAMA_CPP_DIR}"; then + FAIL_DOWNLOAD "failed to create ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +if ! tar -xzf "$TARBALL" -C "${PB_LLAMA_CPP_DIR}" --strip-components=1; then + FAIL_DOWNLOAD "failed to unpack archive into ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Confirm the extracted tree contains what the CMake build relies on. +echo "download.sh: verifying submodule extraction..." +if [ ! -f "${PB_LLAMA_CPP_DIR}/CMakeLists.txt" ] || \ + [ ! -f "${PB_LLAMA_CPP_DIR}/llama.cpp" ] || \ + [ ! -f "${PB_LLAMA_CPP_DIR}/examples/common.cpp" ]; then + FAIL_DOWNLOAD "submodule extraction seems incomplete under ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Mark this staging as complete (used for idempotency on re-runs). +: > "${PB_LLAMA_CPP_DIR}/.programgym_extracted" + +# Clean up the raw archive now that the source is unpacked. +rm -f "$TARBALL" + +echo "download.sh: llama.cpp source staged at ${PB_LLAMA_CPP_DIR}" diff --git a/kuvaus--llamagptj-chat.e022976/environment/executable b/kuvaus--llamagptj-chat.e022976/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..18fc12ae9273a60c841d1b83e2eb5584b878069d --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a006cd086018433a9a0c91fb24cd88304488fad8aafb5c83fb46557abc2bec6 +size 4907056 diff --git a/kuvaus--llamagptj-chat.e022976/environment/harbor_configure_apt_mirror.sh b/kuvaus--llamagptj-chat.e022976/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kuvaus--llamagptj-chat.e022976/environment/harbor_prepare_download_env.sh b/kuvaus--llamagptj-chat.e022976/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kuvaus--llamagptj-chat.e022976/environment/workspace.tar.gz b/kuvaus--llamagptj-chat.e022976/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0da64cb52175821c27e78c973c64a12bc3e2e3fd --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1c4f254ec47b34f6f4698f5ade51833c6b3e6ba41474c7ac4d86a4370283bf6 +size 19918 diff --git a/kuvaus--llamagptj-chat.e022976/instruction.md b/kuvaus--llamagptj-chat.e022976/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kuvaus--llamagptj-chat.e022976/solution/solve.sh b/kuvaus--llamagptj-chat.e022976/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kuvaus--llamagptj-chat.e022976/task.toml b/kuvaus--llamagptj-chat.e022976/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..502b1d1077acd4beb3ddcd44756729070194b008 --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kuvaus--llamagptj-chat.e022976" +description = "Synthetic ProgramGym cleanroom reconstruction task for kuvaus/LlamaGPTJ-chat" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kuvaus__LlamaGPTJ-chat.e022976" +repository = "kuvaus/LlamaGPTJ-chat" +commit = "e022976f04609fd7b6d7da06dfa92abfcb549acc" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.9682026681428497 +test_branches = 4 +test_count = 587 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kuvaus--llamagptj-chat.e022976/tests/Dockerfile b/kuvaus--llamagptj-chat.e022976/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_01.tar.gz b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d46fef164284074e78c5f2a7d674ecb161e957ae --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ffd35b09e3f0ed201d54a8228856ba058f29536633363209e475b12e50b7fbdd +size 22266 diff --git a/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_02.tar.gz b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b425d267566d6f9773f8f82a3ed347d7c626289b --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:425bb47e6a47b0e06a3d4ab7ea868f9480ab633a9b64e412371fd681e1586b4f +size 13718 diff --git a/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_03.tar.gz b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..759f198dd86b4583f2825f6ca5d949b592ba448f --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e160817ab02cd9f611078a639f803edc31e9071369c6ccaad3c2d67e52b00d1 +size 22150 diff --git a/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_04.tar.gz b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..de422b7f97214dcfa5b33a180676ea104592dcb4 --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5732eec3b92e3decdc9e27c856d2f86cdc19a621302186bdf7e88eb36d460cc6 +size 52606 diff --git a/kuvaus--llamagptj-chat.e022976/tests/docker-compose.yaml b/kuvaus--llamagptj-chat.e022976/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/kuvaus--llamagptj-chat.e022976/tests/download.sh b/kuvaus--llamagptj-chat.e022976/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..4ba09fe4d26856d82d9a0c2c4bdf8f965fac8f4d --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/download.sh @@ -0,0 +1,147 @@ +#!/usr/bin/env bash +# +# ProgramGym download stage for kuvaus/LlamaGPTJ-chat. +# +# This script is intended to be SOURCED (`source /source_ro/download.sh`) at the +# repository root while the container still has network access. +# +# Its only job is to PRE-FETCH the git submodule source that this repository's +# build requires but that is NOT present in the checked-out tree: +# `gpt4all-backend/llama.cpp`. The root CMakeLists.txt does +# `add_subdirectory(gpt4all-backend/llama.cpp)`, and gpt4all-backend/CMakeLists.txt +# both links the `llama` target and compiles `llama.cpp/examples/common.cpp`. +# However the llama.cpp submodule is unpacked as an EMPTY directory in the +# checkout (only a `.gitmodules` pointer exists), so the submodule source must +# be provided separately. +# +# IMPORTANT: the validation stage mounts the source tree READ-ONLY at +# /source_ro, so this script must NOT write into the repository tree. Instead +# it downloads, verifies, and unpacks the pinned llama.cpp source archive into a +# separate writable cache directory under /tmp, and exports the path to it via +# $PB_LLAMA_CPP_DIR. The offline build stage (build.sh, running in the writable +# /workspace/source copy) then copies those sources into +# gpt4all-backend/llama.cpp/ itself. We therefore never touch ./git or +# ./gpt4all-backend here. +# +# No compilation, linking, testing, or packaging is performed here. + +# Sourced script guard: fail cleanly whether sourced or executed, using an +# explicit branch rather than a redirected return. +FAIL_DOWNLOAD() { + echo "download.sh: $1" >&2 +} + +# Submodule metadata (embedded explicitly; the download stage cannot read repo +# files, so the URL and checksum are pinned inline). +SUBMODULE_COMMIT="03ceb39c1e729bed4ad1dfa16638a72f1843bf0c" +SUBMODULE_URL="https://codeload.github.com/manyoso/llama.cpp/tar.gz/${SUBMODULE_COMMIT}" +SUBMODULE_SHA256="a02c16d8ae621c3551ab5ee616b16703df89f1c9edf7e03da7917197aa8767e4" + +# Writable staging area OUTSIDE the repository (repo mount is read-only during +# validation). /tmp persists within the build container between the download +# and the offline build stages. +PB_LLAMA_CPP_DIR="/tmp/programgym-llamagptj/llama.cpp-src" +export PB_LLAMA_CPP_DIR +STAGE_ROOT="/tmp/programgym-llamagptj" + +# Toolchain (cmake, make, gcc/g++ 13) is guaranteed by the base image; we only +# need a few archive/curl tools here. Sanity-check they exist. +MISSING_TOOL="" +for tool in curl tar gzip sha256sum mkdir rm; do + if ! command -v "$tool" >/dev/null; then + MISSING_TOOL="$MISSING_TOOL $tool" + fi +done +if [ -n "$MISSING_TOOL" ]; then + FAIL_DOWNLOAD "required tool(s) not found:$MISSING_TOOL" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi +unset MISSING_TOOL + +# Idempotency: if the staged llama.cpp source is already populated with the +# marker we wrote on a previous successful run, do nothing more. +if [ -f "${PB_LLAMA_CPP_DIR}/.programgym_extracted" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/CMakeLists.txt" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/llama.cpp" ] && \ + [ -f "${PB_LLAMA_CPP_DIR}/examples/common.cpp" ]; then + echo "download.sh: llama.cpp source already staged at ${PB_LLAMA_CPP_DIR}; skipping." + return 0 +fi + +# Create the staging root. +if ! mkdir -p "${STAGE_ROOT}" "${PB_LLAMA_CPP_DIR}"; then + FAIL_DOWNLOAD "failed to create staging dirs ${STAGE_ROOT} / ${PB_LLAMA_CPP_DIR}" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +TARBALL="${STAGE_ROOT}/llama.cpp.tar.gz" + +echo "download.sh: fetching llama.cpp submodule archive..." +if ! curl -fsSL --retry 3 -o "$TARBALL" "$SUBMODULE_URL"; then + FAIL_DOWNLOAD "failed to download $SUBMODULE_URL" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Integrity check so the offline build never sees a corrupted submodule tree. +echo "download.sh: verifying archive checksum..." +if ! echo "$SUBMODULE_SHA256 $TARBALL" | sha256sum -c -; then + FAIL_DOWNLOAD "checksum mismatch for $SUBMODULE_URL" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Unpack into the staging dir (replacing any stale/noop placeholder contents). +if [ -e "${PB_LLAMA_CPP_DIR}" ]; then + rm -rf "${PB_LLAMA_CPP_DIR}" +fi +if ! mkdir -p "${PB_LLAMA_CPP_DIR}"; then + FAIL_DOWNLOAD "failed to create ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +if ! tar -xzf "$TARBALL" -C "${PB_LLAMA_CPP_DIR}" --strip-components=1; then + FAIL_DOWNLOAD "failed to unpack archive into ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Confirm the extracted tree contains what the CMake build relies on. +echo "download.sh: verifying submodule extraction..." +if [ ! -f "${PB_LLAMA_CPP_DIR}/CMakeLists.txt" ] || \ + [ ! -f "${PB_LLAMA_CPP_DIR}/llama.cpp" ] || \ + [ ! -f "${PB_LLAMA_CPP_DIR}/examples/common.cpp" ]; then + FAIL_DOWNLOAD "submodule extraction seems incomplete under ${PB_LLAMA_CPP_DIR}" + rm -rf "$STAGE_ROOT" + if [ "${BASH_SOURCE[0]}" = "${0}" ]; then + exit 1 + fi + return 1 +fi + +# Mark this staging as complete (used for idempotency on re-runs). +: > "${PB_LLAMA_CPP_DIR}/.programgym_extracted" + +# Clean up the raw archive now that the source is unpacked. +rm -f "$TARBALL" + +echo "download.sh: llama.cpp source staged at ${PB_LLAMA_CPP_DIR}" diff --git a/kuvaus--llamagptj-chat.e022976/tests/executable b/kuvaus--llamagptj-chat.e022976/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..18fc12ae9273a60c841d1b83e2eb5584b878069d --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a006cd086018433a9a0c91fb24cd88304488fad8aafb5c83fb46557abc2bec6 +size 4907056 diff --git a/kuvaus--llamagptj-chat.e022976/tests/harbor_configure_apt_mirror.sh b/kuvaus--llamagptj-chat.e022976/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/kuvaus--llamagptj-chat.e022976/tests/harbor_prepare_download_env.sh b/kuvaus--llamagptj-chat.e022976/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kuvaus--llamagptj-chat.e022976/tests/programgym_evaluator.py b/kuvaus--llamagptj-chat.e022976/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kuvaus--llamagptj-chat.e022976/tests/programgym_task.json b/kuvaus--llamagptj-chat.e022976/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..9307b16658b527ff7065dec787673a14e808bc7d --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/programgym_task.json @@ -0,0 +1,779 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_args.test_batch_size_long_flag_reflected", + "eval.tests.test_args.test_boolean_flag_no_usage_error[--no-animation]", + "eval.tests.test_args.test_boolean_flag_no_usage_error[--no-interactive]", + "eval.tests.test_args.test_boolean_flag_no_usage_error[--no-saves]", + "eval.tests.test_args.test_boolean_flag_no_usage_error[--run-once]", + "eval.tests.test_args.test_boolean_flag_reaches_help[--no-animation]", + "eval.tests.test_args.test_boolean_flag_reaches_help[--no-interactive]", + "eval.tests.test_args.test_boolean_flag_reaches_help[--no-saves]", + "eval.tests.test_args.test_boolean_flag_reaches_help[--run-once]", + "eval.tests.test_args.test_broad_numeric_reflection_all_rows", + "eval.tests.test_args.test_context_erase_zero_boundary_reflected", + "eval.tests.test_args.test_empty_string_filename_flags_accepted[args0]", + "eval.tests.test_args.test_empty_string_filename_flags_accepted[args1]", + "eval.tests.test_args.test_empty_string_filename_flags_accepted[args2]", + "eval.tests.test_args.test_empty_string_filename_flags_accepted[args3]", + "eval.tests.test_args.test_empty_string_float_value_aborts", + "eval.tests.test_args.test_empty_string_int_value_aborts", + "eval.tests.test_args.test_equals_form_empty_value_rejected", + "eval.tests.test_args.test_equals_form_flag_rejected_as_unknown", + "eval.tests.test_args.test_float_flag_reflected[--context_erase-0.4-0.4-percent of context to erase]", + "eval.tests.test_args.test_float_flag_reflected[--repeat_penalty-2.3-2.3-repeat_penalty]", + "eval.tests.test_args.test_float_flag_reflected[--temp-0.7-0.7-temperature]", + "eval.tests.test_args.test_float_flag_reflected[--top_p-0.5-0.5-top-p sampling]", + "eval.tests.test_args.test_float_overflow_out_of_range_aborts", + "eval.tests.test_args.test_float_trailing_garbage_accepted", + "eval.tests.test_args.test_int_flag_reflected[--repeat_last_n-last n tokens to penalize]", + "eval.tests.test_args.test_int_flag_reflected[--top_k-top-k sampling]", + "eval.tests.test_args.test_int_flag_reflected[-b-batch size for prompt processing]", + "eval.tests.test_args.test_int_flag_reflected[-t-number of threads to use]", + "eval.tests.test_args.test_int_min_in_range_accepted", + "eval.tests.test_args.test_int_out_of_range_aborts", + "eval.tests.test_args.test_int_trailing_garbage_accepted", + "eval.tests.test_args.test_leading_plus_int_accepted", + "eval.tests.test_args.test_lone_plus_int_value_aborts", + "eval.tests.test_args.test_model_flag_reflected", + "eval.tests.test_args.test_model_load_loading_line_starts_with_appname", + "eval.tests.test_args.test_model_load_reached_after_numeric_flag[--temp-0.7]", + "eval.tests.test_args.test_model_load_reached_after_numeric_flag[--threads-4]", + "eval.tests.test_args.test_model_load_reached_after_numeric_flag[--top_k-40]", + "eval.tests.test_args.test_model_load_reached_after_numeric_flag[-n-150]", + "eval.tests.test_args.test_model_load_reached_after_numeric_flag[-t-2]", + "eval.tests.test_args.test_model_load_reached_with_context_switches", + "eval.tests.test_args.test_model_load_reached_with_fixed_prompt", + "eval.tests.test_args.test_model_load_reached_with_save_metadata", + "eval.tests.test_args.test_model_load_reached_with_template_and_log_flags", + "eval.tests.test_args.test_model_load_reached_with_wrap_tokens", + "eval.tests.test_args.test_model_long_flag_reflected", + "eval.tests.test_args.test_n_ctx_flag_reflected", + "eval.tests.test_args.test_n_ctx_int_max_boundary_reflected", + "eval.tests.test_args.test_n_ctx_moderate_value_reflected", + "eval.tests.test_args.test_n_predict_flag_reflected[--n_predict-n_predict-number of tokens to predict]", + "eval.tests.test_args.test_n_predict_flag_reflected[-n-n_predict-number of tokens to predict]", + "eval.tests.test_args.test_n_predict_zero_boundary_reflected", + "eval.tests.test_args.test_negative_float_accepted", + "eval.tests.test_args.test_non_numeric_float_value_aborts[args0]", + "eval.tests.test_args.test_non_numeric_float_value_aborts[args1]", + "eval.tests.test_args.test_non_numeric_float_value_aborts[args2]", + "eval.tests.test_args.test_non_numeric_int_value_aborts[args0]", + "eval.tests.test_args.test_non_numeric_int_value_aborts[args1]", + "eval.tests.test_args.test_non_numeric_int_value_aborts[args2]", + "eval.tests.test_args.test_non_numeric_int_value_aborts[args3]", + "eval.tests.test_args.test_prompt_swallows_help_flag_then_loads", + "eval.tests.test_args.test_repeated_flag_last_wins[--temp-temperature]", + "eval.tests.test_args.test_repeated_flag_last_wins[--top_p-top-p sampling]", + "eval.tests.test_args.test_repeated_int_flag_last_wins[--top_k-top-k sampling]", + "eval.tests.test_args.test_repeated_int_flag_last_wins[-n-number of tokens to predict]", + "eval.tests.test_args.test_repeated_model_last_wins", + "eval.tests.test_args.test_repeated_save_name_last_wins", + "eval.tests.test_args.test_save_dir_default_is_binary_parent", + "eval.tests.test_args.test_save_dir_option_reflected", + "eval.tests.test_args.test_save_name_reflected", + "eval.tests.test_args.test_scientific_and_plus_float_parsing_distinct_flags[--context_erase-2.5e-1-0.2-percent of context to erase]", + "eval.tests.test_args.test_scientific_and_plus_float_parsing_distinct_flags[--repeat_penalty-1e2-100.0-repeat_penalty]", + "eval.tests.test_args.test_scientific_and_plus_float_parsing_distinct_flags[--temp-+0.5-0.5-temperature]", + "eval.tests.test_args.test_scientific_float_accepted", + "eval.tests.test_args.test_scientific_positive_exponent_float_accepted", + "eval.tests.test_args.test_seed_long_form_with_random_prompt_reaches_help", + "eval.tests.test_args.test_short_seed_flag_reaches_help", + "eval.tests.test_args.test_short_seed_trailing_null_aborts", + "eval.tests.test_args.test_signed_negative_int_accepted", + "eval.tests.test_args.test_string_filename_flags_reach_help[args0]", + "eval.tests.test_args.test_string_filename_flags_reach_help[args1]", + "eval.tests.test_args.test_string_filename_flags_reach_help[args2]", + "eval.tests.test_args.test_string_filename_flags_reach_help[args3]", + "eval.tests.test_args.test_string_filename_flags_reach_help[args4]", + "eval.tests.test_args.test_top_k_zero_boundary_reflected", + "eval.tests.test_args.test_trailing_flag_never_prints_usage[args0]", + "eval.tests.test_args.test_trailing_flag_never_prints_usage[args1]", + "eval.tests.test_args.test_trailing_flag_never_prints_usage[args2]", + "eval.tests.test_args.test_trailing_flag_never_prints_usage[args3]", + "eval.tests.test_args.test_trailing_model_flag_swallows_next_token", + "eval.tests.test_args.test_trailing_prompt_swallows_next_token", + "eval.tests.test_args.test_trailing_seed_reports_null_string_error", + "eval.tests.test_args.test_trailing_value_flag_aborts_on_null[args0]", + "eval.tests.test_args.test_trailing_value_flag_aborts_on_null[args1]", + "eval.tests.test_args.test_trailing_value_flag_aborts_on_null[args2]", + "eval.tests.test_args.test_trailing_value_flag_aborts_on_null[args3]", + "eval.tests.test_args.test_trailing_value_flag_aborts_on_null[args4]", + "eval.tests.test_args.test_whitespace_padded_int_accepted", + "eval.tests.test_cli.test_avx_diagnosis_matches_known_variant", + "eval.tests.test_cli.test_help_clean_emits_no_json_parse[--help]", + "eval.tests.test_cli.test_help_clean_emits_no_json_parse[-h]", + "eval.tests.test_cli.test_help_docs_build_default_threads[--help]", + "eval.tests.test_cli.test_help_docs_build_default_threads[-h]", + "eval.tests.test_cli.test_help_docs_interactive_commands[--help]", + "eval.tests.test_cli.test_help_docs_interactive_commands[-h]", + "eval.tests.test_cli.test_help_docs_load_file_rows_default_no", + "eval.tests.test_cli.test_help_docs_model_default_path", + "eval.tests.test_cli.test_help_docs_options[--help]", + "eval.tests.test_cli.test_help_docs_options[-h]", + "eval.tests.test_cli.test_help_docs_prompt_row_default_empty", + "eval.tests.test_cli.test_help_docs_save_dir_default_program_dir", + "eval.tests.test_cli.test_help_docs_save_name_default", + "eval.tests.test_cli.test_help_docs_save_name_rows_current_model_state", + "eval.tests.test_cli.test_help_docs_wrap_token_rows_default_empty", + "eval.tests.test_cli.test_help_exits_zero_with_usage_and_options[--help]", + "eval.tests.test_cli.test_help_exits_zero_with_usage_and_options[-h]", + "eval.tests.test_cli.test_help_prints_usage_to_stderr[--help]", + "eval.tests.test_cli.test_help_prints_usage_to_stderr[-h]", + "eval.tests.test_cli.test_help_then_version_help_wins", + "eval.tests.test_cli.test_help_usage_line_prefix_exact[--help]", + "eval.tests.test_cli.test_help_usage_line_prefix_exact[-h]", + "eval.tests.test_cli.test_prompt_long_flag_alias_reaches_help", + "eval.tests.test_cli.test_prompt_option_reaches_help[Hello world]", + "eval.tests.test_cli.test_prompt_option_reaches_help[What is 2+2?]", + "eval.tests.test_cli.test_prompt_option_reaches_help[capitalized Prompt]", + "eval.tests.test_cli.test_random_prompt_default_seed_reaches_help", + "eval.tests.test_cli.test_random_prompt_with_seed_reaches_help[0]", + "eval.tests.test_cli.test_random_prompt_with_seed_reaches_help[42]", + "eval.tests.test_cli.test_random_prompt_with_seed_reaches_help[7]", + "eval.tests.test_cli.test_seed_option_alone_reaches_help", + "eval.tests.test_cli.test_single_dash_unknown_argument", + "eval.tests.test_cli.test_startup_avx_diagnosis_full_phrase[--help]", + "eval.tests.test_cli.test_startup_avx_diagnosis_full_phrase[--version]", + "eval.tests.test_cli.test_startup_avx_diagnosis_full_phrase[-h]", + "eval.tests.test_cli.test_startup_avx_diagnosis_full_phrase[-v]", + "eval.tests.test_cli.test_startup_banner_exact_first_line[--help]", + "eval.tests.test_cli.test_startup_banner_exact_first_line[--version]", + "eval.tests.test_cli.test_startup_banner_exact_first_line[-h]", + "eval.tests.test_cli.test_startup_banner_exact_first_line[-v]", + "eval.tests.test_cli.test_unknown_argument_after_valid_option_still_rejected", + "eval.tests.test_cli.test_unknown_argument_before_version_blocks_version", + "eval.tests.test_cli.test_unknown_argument_exits_zero_after_usage[--definitely_not_an_option]", + "eval.tests.test_cli.test_unknown_argument_exits_zero_after_usage[--frobnicate]", + "eval.tests.test_cli.test_unknown_argument_exits_zero_after_usage[xyzzy]", + "eval.tests.test_cli.test_unknown_argument_names_bad_option[--definitely_not_an_option]", + "eval.tests.test_cli.test_unknown_argument_names_bad_option[--frobnicate]", + "eval.tests.test_cli.test_unknown_argument_names_bad_option[-z]", + "eval.tests.test_cli.test_unknown_argument_names_bad_option[xyzzy]", + "eval.tests.test_cli.test_unknown_argument_sequence_multiple", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[--HELP]", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[--Help]", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[--Version]", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[-H]", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[-P]", + "eval.tests.test_cli.test_uppercase_flag_variants_rejected[-V]", + "eval.tests.test_cli.test_valid_options_then_version_still_prints_exact_block[pre0]", + "eval.tests.test_cli.test_valid_options_then_version_still_prints_exact_block[pre1]", + "eval.tests.test_cli.test_valid_options_then_version_still_prints_exact_block[pre2]", + "eval.tests.test_cli.test_version_does_not_print_usage[--version]", + "eval.tests.test_cli.test_version_does_not_print_usage[-v]", + "eval.tests.test_cli.test_version_exits_zero_with_identity[--version]", + "eval.tests.test_cli.test_version_exits_zero_with_identity[-v]", + "eval.tests.test_cli.test_version_prints_full_license_block[--version]", + "eval.tests.test_cli.test_version_prints_full_license_block[-v]", + "eval.tests.test_cli.test_version_prints_identity_lines[--version]", + "eval.tests.test_cli.test_version_prints_identity_lines[-v]", + "eval.tests.test_cli.test_version_then_help_version_wins", + "eval.tests.test_json.test_boolean_value_false_parses", + "eval.tests.test_json.test_cli_then_json_wins", + "eval.tests.test_json.test_directory_as_json_parses_empty_silently", + "eval.tests.test_json.test_empty_json_file_parses_cleanly", + "eval.tests.test_json.test_empty_json_filename_message", + "eval.tests.test_json.test_empty_json_filename_skips_file_read", + "eval.tests.test_json.test_garbage_json_file_parses_cleanly", + "eval.tests.test_json.test_invalid_boolean_string_aborts", + "eval.tests.test_json.test_json_abort_before_version", + "eval.tests.test_json.test_json_duplicate_key_last_wins", + "eval.tests.test_json.test_json_empty_string_value_not_captured_keeps_default", + "eval.tests.test_json.test_json_key_case_sensitive_ignored", + "eval.tests.test_json.test_json_load_template_accepted", + "eval.tests.test_json.test_json_malformed_brace_recover[\"temp\": 0.99, \"top_k\": 5]", + "eval.tests.test_json.test_json_malformed_brace_recover[\"temp\":0.2}]", + "eval.tests.test_json.test_json_model_reflected", + "eval.tests.test_json.test_json_multi_field_all_reflected", + "eval.tests.test_json.test_json_n_ctx_reflected", + "eval.tests.test_json.test_json_n_ctx_then_cli_n_ctx_wins", + "eval.tests.test_json.test_json_no_animation_true_enables_model_reach", + "eval.tests.test_json.test_json_precedence_does_not_abort", + "eval.tests.test_json.test_json_quoted_string_fields_do_not_abort", + "eval.tests.test_json.test_json_save_dir_accepted", + "eval.tests.test_json.test_json_save_log_and_load_log_accepted", + "eval.tests.test_json.test_json_save_name_reflected", + "eval.tests.test_json.test_json_single_char_file_parses_cleanly", + "eval.tests.test_json.test_json_then_cli_flag_wins", + "eval.tests.test_json.test_json_then_version_exits_cleanly[--version]", + "eval.tests.test_json.test_json_then_version_exits_cleanly[-v]", + "eval.tests.test_json.test_json_unknown_key_ignored", + "eval.tests.test_json.test_json_unquoted_string_model_keeps_trailing_brace", + "eval.tests.test_json.test_json_value_with_surrounding_spaces_reflected", + "eval.tests.test_json.test_json_whitespace_only_file_parses_cleanly", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[n_batch]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[n_predict]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[seed]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[temp]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[threads]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[top_k]", + "eval.tests.test_json.test_json_with_multiple_unquoted_keys_parses[top_p]", + "eval.tests.test_json.test_load_json_empty_filename_message", + "eval.tests.test_json.test_load_json_long_form_parses", + "eval.tests.test_json.test_nonexistent_json_parses_empty_to_defaults", + "eval.tests.test_json.test_nonexistent_json_prints_open_error", + "eval.tests.test_json.test_nonexistent_json_prints_parse_line", + "eval.tests.test_json.test_quoted_boolean_case_insensitive[FALSE]", + "eval.tests.test_json.test_quoted_boolean_case_insensitive[False]", + "eval.tests.test_json.test_quoted_boolean_case_insensitive[TRUE]", + "eval.tests.test_json.test_quoted_boolean_case_insensitive[True]", + "eval.tests.test_json.test_quoted_boolean_value_parses[no-animation]", + "eval.tests.test_json.test_quoted_boolean_value_parses[no-interactive]", + "eval.tests.test_json.test_quoted_boolean_value_parses[no-saves]", + "eval.tests.test_json.test_quoted_boolean_value_parses[run-once]", + "eval.tests.test_json.test_quoted_float_json_aborts_stof[context_erase]", + "eval.tests.test_json.test_quoted_float_json_aborts_stof[repeat_penalty]", + "eval.tests.test_json.test_quoted_float_json_aborts_stof[temp]", + "eval.tests.test_json.test_quoted_float_json_aborts_stof[top_p]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[n_batch]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[n_predict]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[repeat_last_n]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[seed]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[threads]", + "eval.tests.test_json.test_quoted_int_json_aborts_stoi[top_k]", + "eval.tests.test_json.test_quoted_nonnumeric_float_aborts", + "eval.tests.test_json.test_repeat_json_flag_last_file_wins", + "eval.tests.test_json.test_unquoted_boolean_literal_aborts[no-animation]", + "eval.tests.test_json.test_unquoted_boolean_literal_aborts[no-interactive]", + "eval.tests.test_json.test_unquoted_boolean_literal_aborts[no-saves]", + "eval.tests.test_json.test_unquoted_boolean_literal_aborts[run-once]", + "eval.tests.test_json.test_unquoted_int_json_reflected[n_predict-77-number of tokens to predict]", + "eval.tests.test_json.test_unquoted_int_json_reflected[top_k-40-top-k sampling]", + "eval.tests.test_json.test_unquoted_nonnumeric_float_aborts", + "eval.tests.test_json.test_unquoted_nonnumeric_int_aborts_stoi[seed]", + "eval.tests.test_json.test_unquoted_nonnumeric_int_aborts_stoi[top_k]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[context_erase-0.4-percent of context to erase]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[n_batch-6-batch size for prompt processing]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[n_predict-77-number of tokens to predict]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[repeat_last_n-128-last n tokens to penalize]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[repeat_penalty-2.3-repeat_penalty]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[temp-0.9-temperature]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[threads-3-number of threads to use]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[top_k-40-top-k sampling]", + "eval.tests.test_json.test_unquoted_numeric_json_reflected[top_p-0.5-top-p sampling]", + "eval.tests.test_modelreach.test_empty_json_file_then_model_reach", + "eval.tests.test_modelreach.test_json_boolean_combo_model_reach", + "eval.tests.test_modelreach.test_json_no_animation_false_keeps_animation_on_model_reach", + "eval.tests.test_modelreach.test_loading_line_reflects_exact_model_argument", + "eval.tests.test_modelreach.test_missing_json_then_model_reach_prints_open_error_and_loading", + "eval.tests.test_modelreach.test_model_reach_default_animation_prints_loading[extra0]", + "eval.tests.test_modelreach.test_model_reach_default_animation_prints_loading[extra1]", + "eval.tests.test_modelreach.test_model_reach_default_animation_prints_loading[extra2]", + "eval.tests.test_modelreach.test_model_reach_default_animation_prints_loading[extra3]", + "eval.tests.test_modelreach.test_model_reach_numeric_flags_default_animation", + "eval.tests.test_modelreach.test_no_animation_flag_before_model_still_loads" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_llmodel_module02.test_combined_parameter_flags_all_reach_loader[extra0]", + "eval.tests.test_llmodel_module02.test_combined_parameter_flags_all_reach_loader[extra1]", + "eval.tests.test_llmodel_module02.test_combined_parameter_flags_all_reach_loader[extra2]", + "eval.tests.test_llmodel_module02.test_combined_parameter_flags_all_reach_loader[extra3]", + "eval.tests.test_llmodel_module02.test_help_flag_after_other_flags_prints_exact_usage", + "eval.tests.test_llmodel_module02.test_help_flag_prints_exact_usage_on_stderr[--help]", + "eval.tests.test_llmodel_module02.test_help_flag_prints_exact_usage_on_stderr[-h]", + "eval.tests.test_llmodel_module02.test_interactive_mode_with_batch_stdin_reaches_loader", + "eval.tests.test_llmodel_module02.test_load_json_all_numeric_fields_parsed_before_loader", + "eval.tests.test_llmodel_module02.test_load_json_config_reaches_backend_loader[gptj]", + "eval.tests.test_llmodel_module02.test_load_json_config_reaches_backend_loader[llama]", + "eval.tests.test_llmodel_module02.test_load_json_config_reaches_backend_loader[mpt]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_boolean_aborts_with_exact_stderr[2]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_boolean_aborts_with_exact_stderr[maybe]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_boolean_aborts_with_exact_stderr[notabool]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_float_aborts_with_exact_stderr[temp]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_float_aborts_with_exact_stderr[top_p]", + "eval.tests.test_llmodel_module02.test_load_json_invalid_float_on_repeat_penalty_aborts_with_exact_stderr", + "eval.tests.test_llmodel_module02.test_load_json_invalid_integer_aborts_with_exact_stderr", + "eval.tests.test_llmodel_module02.test_load_json_missing_file_reports_stderr_and_faults", + "eval.tests.test_llmodel_module02.test_load_json_short_flag_alias_reaches_backend_loader[gptj]", + "eval.tests.test_llmodel_module02.test_load_json_short_flag_alias_reaches_backend_loader[llama]", + "eval.tests.test_llmodel_module02.test_load_json_short_flag_alias_reaches_backend_loader[mpt]", + "eval.tests.test_llmodel_module02.test_load_log_flag_accepted_before_loader", + "eval.tests.test_llmodel_module02.test_load_template_txt_is_accepted_before_loader", + "eval.tests.test_llmodel_module02.test_malformed_existing_path_faults_with_loading_echo[bad_magic]", + "eval.tests.test_llmodel_module02.test_malformed_existing_path_faults_with_loading_echo[directory]", + "eval.tests.test_llmodel_module02.test_malformed_existing_path_faults_with_loading_echo[empty]", + "eval.tests.test_llmodel_module02.test_malformed_existing_path_faults_with_loading_echo[two_byte_trunc]", + "eval.tests.test_llmodel_module02.test_model_create_dispatch_selects_backend_and_reaches_loader[gptj]", + "eval.tests.test_llmodel_module02.test_model_create_dispatch_selects_backend_and_reaches_loader[llama]", + "eval.tests.test_llmodel_module02.test_model_create_dispatch_selects_backend_and_reaches_loader[mpt]", + "eval.tests.test_llmodel_module02.test_model_dash_prefixed_path_with_magic", + "eval.tests.test_llmodel_module02.test_model_load_output_is_deterministic_and_matches_oracle[gptj]", + "eval.tests.test_llmodel_module02.test_model_load_output_is_deterministic_and_matches_oracle[llama]", + "eval.tests.test_llmodel_module02.test_model_load_output_is_deterministic_and_matches_oracle[mpt]", + "eval.tests.test_llmodel_module02.test_model_long_flag_with_save_dir_reaches_loader", + "eval.tests.test_llmodel_module02.test_model_long_model_flag_selects_backend_and_reaches_loader[gptj]", + "eval.tests.test_llmodel_module02.test_model_long_model_flag_selects_backend_and_reaches_loader[llama]", + "eval.tests.test_llmodel_module02.test_model_long_model_flag_selects_backend_and_reaches_loader[mpt]", + "eval.tests.test_llmodel_module02.test_model_nonexistent_path_faults_without_loading_echo", + "eval.tests.test_llmodel_module02.test_model_space_in_path_is_echoed_and_loads", + "eval.tests.test_llmodel_module02.test_mpt_no_saves_gates_off_save_path_and_forwards_slashsave", + "eval.tests.test_llmodel_module02.test_mpt_save_overwrite_different_size_is_rejected", + "eval.tests.test_llmodel_module02.test_mpt_save_reaches_state_size_and_save_state_data[16-2163220]", + "eval.tests.test_llmodel_module02.test_mpt_save_reaches_state_size_and_save_state_data[4-2162836]", + "eval.tests.test_llmodel_module02.test_mpt_save_reaches_state_size_and_save_state_data[8-2162964]", + "eval.tests.test_llmodel_module02.test_mpt_save_renamed_destination_writes_custom_files", + "eval.tests.test_llmodel_module02.test_mpt_save_then_load_reaches_restore_state_data", + "eval.tests.test_llmodel_module02.test_mpt_success_interactive_run_once_reaches_prompt", + "eval.tests.test_llmodel_module02.test_mpt_success_load_is_deterministic_across_repeated_runs", + "eval.tests.test_llmodel_module02.test_mpt_success_load_reaches_postload_setthreadcount_prompt_destroy[16]", + "eval.tests.test_llmodel_module02.test_mpt_success_load_reaches_postload_setthreadcount_prompt_destroy[4]", + "eval.tests.test_llmodel_module02.test_mpt_success_load_reaches_postload_setthreadcount_prompt_destroy[8]", + "eval.tests.test_llmodel_module02.test_mpt_success_long_model_flag_reaches_postload", + "eval.tests.test_llmodel_module02.test_mpt_success_prompt_exceeds_larger_ctx_still_errors", + "eval.tests.test_llmodel_module02.test_mpt_success_prompt_token_count_scales_with_prompt[The answer is 42.-205]", + "eval.tests.test_llmodel_module02.test_mpt_success_prompt_token_count_scales_with_prompt[hello world-199]", + "eval.tests.test_llmodel_module02.test_mpt_success_prompt_token_count_scales_with_prompt[hi-190]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra0]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra10]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra11]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra12]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra13]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra14]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra15]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra16]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra1]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra2]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra3]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra4]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra5]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra6]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra7]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra8]", + "eval.tests.test_llmodel_module02.test_parameter_flag_is_accepted_and_reaches_loader[extra9]", + "eval.tests.test_llmodel_module02.test_save_dir_flag_accepted_before_loader", + "eval.tests.test_llmodel_module02.test_save_log_flag_accepted_before_loader", + "eval.tests.test_llmodel_module02.test_save_name_flag_accepted_before_loader", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[----malformed]", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[--bogus_xyz]", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[--does-not-exist]", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[--no_such_flag]", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[-Yz]", + "eval.tests.test_llmodel_module02.test_unknown_argument_prints_exact_error_and_usage[-Z]", + "eval.tests.test_llmodel_module02.test_version_flag_prints_exact_license_block[--version]", + "eval.tests.test_llmodel_module02.test_version_flag_prints_exact_license_block[-v]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_backend_wtype_variants.test_gptj_f32_wtype_model_loads_successfully", + "eval.tests.test_backend_wtype_variants.test_gptj_f32_wtype_save_and_load_state", + "eval.tests.test_backend_wtype_variants.test_mpt_f32_wtype_model_loads_successfully", + "eval.tests.test_backend_wtype_variants.test_mpt_special_and_f32_wtype_combined", + "eval.tests.test_backend_wtype_variants.test_mpt_special_token_at_tail_vocab_still_loads", + "eval.tests.test_backend_wtype_variants.test_mpt_special_token_vocab_loads_successfully", + "eval.tests.test_cli_behaviors.test_banner_and_avx_line_printed_before_loading", + "eval.tests.test_cli_behaviors.test_help_lists_usage_on_stderr[long_help]", + "eval.tests.test_cli_behaviors.test_help_lists_usage_on_stderr[short_help]", + "eval.tests.test_cli_behaviors.test_sampling_flags_accepted_with_load_failure", + "eval.tests.test_cli_behaviors.test_unknown_argument_reports_error", + "eval.tests.test_cli_behaviors.test_version_prints_about_and_license[long_version]", + "eval.tests.test_cli_behaviors.test_version_prints_about_and_license[short_version]", + "eval.tests.test_cli_options_reach_prompt.test_begin_end_tokens_frame_generated_response[gptj]", + "eval.tests.test_cli_options_reach_prompt.test_begin_end_tokens_frame_generated_response[llama]", + "eval.tests.test_cli_options_reach_prompt.test_begin_end_tokens_frame_generated_response[mpt]", + "eval.tests.test_cli_options_reach_prompt.test_load_json_empty_filename_reports_and_continues", + "eval.tests.test_cli_options_reach_prompt.test_load_json_string_options_apply_prompt", + "eval.tests.test_cli_options_reach_prompt.test_long_prompt_forces_multiple_batch_iterations[gptj]", + "eval.tests.test_cli_options_reach_prompt.test_long_prompt_forces_multiple_batch_iterations[llama]", + "eval.tests.test_cli_options_reach_prompt.test_long_prompt_forces_multiple_batch_iterations[mpt]", + "eval.tests.test_cli_options_reach_prompt.test_random_prompt_flag_uses_seeded_default_prompt[gptj]", + "eval.tests.test_cli_options_reach_prompt.test_random_prompt_flag_uses_seeded_default_prompt[llama]", + "eval.tests.test_cli_options_reach_prompt.test_random_prompt_flag_uses_seeded_default_prompt[mpt]", + "eval.tests.test_dispatch_crash.test_empty_model_crashes", + "eval.tests.test_dispatch_crash.test_gptj_magic_dispatches_and_fails_cleanly", + "eval.tests.test_dispatch_crash.test_near_miss_magic_crashes", + "eval.tests.test_dispatch_crash.test_nonexistent_model_crashes", + "eval.tests.test_dispatch_crash.test_unrecognised_magic_crashes", + "eval.tests.test_gptj_load.test_gptj_hparams_reported_to_stdout", + "eval.tests.test_gptj_load.test_gptj_load_failure_prints_backend_prefix", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[bad_f16]", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[bad_vocab_size]", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[unknown_ftype]", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[unknown_tensor]", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[wrong_shape]", + "eval.tests.test_gptj_load.test_gptj_load_rejects_malformed_model[wrong_size]", + "eval.tests.test_gptj_load.test_gptj_magic_only_reports_bad_vocab", + "eval.tests.test_gptj_success.test_gptj_deep_predict_loop_with_larger_vocab", + "eval.tests.test_gptj_success.test_gptj_generation_runs_batch_and_predict_loops", + "eval.tests.test_gptj_success.test_gptj_no_prediction_still_processes_batch", + "eval.tests.test_gptj_success.test_gptj_no_saves_skips_state_commands", + "eval.tests.test_gptj_success.test_gptj_oversized_prompt_exceeds_context", + "eval.tests.test_gptj_success.test_gptj_sampling_flags_drive_inference", + "eval.tests.test_gptj_success.test_gptj_save_state_custom_filename", + "eval.tests.test_gptj_success.test_gptj_save_state_writes_state_bin", + "eval.tests.test_gptj_success.test_gptj_save_then_load_state_roundtrip", + "eval.tests.test_gptj_success.test_gptj_success_path_prints_prompt_echo", + "eval.tests.test_gptj_success.test_gptj_success_save_log_writes_session_file", + "eval.tests.test_gptj_success.test_gptj_temp_zero_runs_greedy_generation", + "eval.tests.test_gptj_success.test_gptj_threads_flag_selects_context_threads", + "eval.tests.test_gptj_success.test_gptj_valid_model_loads_successfully", + "eval.tests.test_interactive_commands.test_interactive_continuous_multiturn_loop", + "eval.tests.test_interactive_commands.test_interactive_save_traversal_filename_uses_default", + "eval.tests.test_interactive_commands.test_interactive_slash_about_prints_version", + "eval.tests.test_interactive_commands.test_interactive_slash_help_prints_usage_to_stderr", + "eval.tests.test_interactive_commands.test_interactive_slash_reset_prints_context_reset", + "eval.tests.test_interactive_commands.test_interactive_slash_reset_survives_no_saves", + "eval.tests.test_llama_load.test_llama_load_failure_propagates_to_chat_exit", + "eval.tests.test_llama_load.test_llama_load_failure_uses_llama_prefix", + "eval.tests.test_llama_load.test_llama_truncated_model_reports_eof_error[magic_only]", + "eval.tests.test_llama_load.test_llama_truncated_model_reports_eof_error[truncated_header]", + "eval.tests.test_llama_success.test_llama_generation_runs_batch_and_predict_loops", + "eval.tests.test_llama_success.test_llama_large_vocab_predicts_multiple_tokens", + "eval.tests.test_llama_success.test_llama_no_saves_skips_state_commands", + "eval.tests.test_llama_success.test_llama_oversized_prompt_exceeds_context", + "eval.tests.test_llama_success.test_llama_sampling_flags_drive_inference", + "eval.tests.test_llama_success.test_llama_save_state_custom_filename", + "eval.tests.test_llama_success.test_llama_save_state_writes_state_bin", + "eval.tests.test_llama_success.test_llama_save_then_load_state_roundtrip", + "eval.tests.test_llama_success.test_llama_success_path_prints_prompt_echo", + "eval.tests.test_llama_success.test_llama_success_save_log_writes_session_file", + "eval.tests.test_llama_success.test_llama_temp_zero_stops_after_eos", + "eval.tests.test_llama_success.test_llama_threads_flag_selects_context_threads", + "eval.tests.test_llama_success.test_llama_valid_model_loads_successfully", + "eval.tests.test_module_state_paths.test_empty_prompt_runs_cleanly[gptj]", + "eval.tests.test_module_state_paths.test_empty_prompt_runs_cleanly[llama]", + "eval.tests.test_module_state_paths.test_empty_prompt_runs_cleanly[mpt]", + "eval.tests.test_module_state_paths.test_llama_save_overwrites_correct_size_bin", + "eval.tests.test_module_state_paths.test_load_missing_ctx_file_fails_before_size_gate[gptj]", + "eval.tests.test_module_state_paths.test_load_missing_ctx_file_fails_before_size_gate[llama]", + "eval.tests.test_module_state_paths.test_load_missing_ctx_file_fails_before_size_gate[mpt]", + "eval.tests.test_module_state_paths.test_load_rejects_wrong_size_binary[gptj]", + "eval.tests.test_module_state_paths.test_load_rejects_wrong_size_binary[mpt]", + "eval.tests.test_module_state_paths.test_save_rejects_wrong_size_overwrite[gptj]", + "eval.tests.test_module_state_paths.test_save_rejects_wrong_size_overwrite[llama]", + "eval.tests.test_module_state_paths.test_save_rejects_wrong_size_overwrite[mpt]", + "eval.tests.test_mpt_load.test_mpt_hparams_reported_to_stdout", + "eval.tests.test_mpt_load.test_mpt_load_failure_prints_backend_diagnostic", + "eval.tests.test_mpt_load.test_mpt_load_rejects_malformed_model[bad_f16]", + "eval.tests.test_mpt_load.test_mpt_load_rejects_malformed_model[bad_vocab_size]", + "eval.tests.test_mpt_load.test_mpt_load_rejects_malformed_model[unknown_tensor]", + "eval.tests.test_mpt_load.test_mpt_load_rejects_malformed_model[wrong_shape]", + "eval.tests.test_mpt_load.test_mpt_load_rejects_malformed_model[wrong_size]", + "eval.tests.test_mpt_success.test_mpt_deep_predict_loop_with_larger_vocab", + "eval.tests.test_mpt_success.test_mpt_generation_runs_batch_and_predict_loops", + "eval.tests.test_mpt_success.test_mpt_no_prediction_still_processes_batch", + "eval.tests.test_mpt_success.test_mpt_no_saves_skips_state_commands", + "eval.tests.test_mpt_success.test_mpt_oversized_prompt_exceeds_context", + "eval.tests.test_mpt_success.test_mpt_sampling_flags_drive_inference", + "eval.tests.test_mpt_success.test_mpt_save_state_custom_filename", + "eval.tests.test_mpt_success.test_mpt_save_state_writes_state_bin", + "eval.tests.test_mpt_success.test_mpt_save_then_load_state_roundtrip", + "eval.tests.test_mpt_success.test_mpt_success_path_prints_prompt_echo", + "eval.tests.test_mpt_success.test_mpt_success_save_log_writes_session_file", + "eval.tests.test_mpt_success.test_mpt_temp_zero_runs_greedy_generation", + "eval.tests.test_mpt_success.test_mpt_threads_flag_selects_context_threads", + "eval.tests.test_mpt_success.test_mpt_valid_model_loads_successfully" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_edges.test_sampling_parameter_combo_produces_exact_generation", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_edges.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_loading.test_relative_model_path_resolved_from_cwd", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_loading.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_loading.test_valid_model_loads_and_streams_diagnostics", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_loading.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_mpt_special_tokens.test_mpt_model_dispatches_and_special_vocab_loads", + "reasons": [ + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_mpt_special_tokens.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_template_config.test_load_json_missing_file_reports_error_and_continues_with_default", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_template_config.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_template_config.test_load_template_missing_file_reverts_and_reports", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_template_config.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_edges.test_digit_only_prompts_tokenize_exact_count[007]", + "eval.tests.test_edges.test_digit_only_prompts_tokenize_exact_count[123]", + "eval.tests.test_edges.test_digit_only_prompts_tokenize_exact_count[42-7-99]", + "eval.tests.test_edges.test_digit_only_prompts_tokenize_exact_count[test123abc]", + "eval.tests.test_edges.test_empty_prompt_still_generates", + "eval.tests.test_edges.test_n_predict_one_emits_single_exact_token", + "eval.tests.test_edges.test_n_predict_zero_produces_no_generation", + "eval.tests.test_edges.test_nucleus_top_p_truncation_is_deterministic", + "eval.tests.test_edges.test_sampling_parameter_combo_produces_exact_generation", + "eval.tests.test_edges.test_top_k_above_vocab_is_never_successful[1000]", + "eval.tests.test_edges.test_top_k_above_vocab_is_never_successful[300]", + "eval.tests.test_edges.test_top_k_greater_than_vocab_aborts", + "eval.tests.test_edges.test_top_p_one_accepts_full_nucleus", + "eval.tests.test_interactive.test_interactive_generation_streams_to_stdout", + "eval.tests.test_interactive.test_interactive_response_length_equals_n_predict", + "eval.tests.test_interactive.test_interactive_stdin_prompt_generates_response", + "eval.tests.test_interactive.test_interactive_stop_word_skips_generation[exit]", + "eval.tests.test_interactive.test_interactive_stop_word_skips_generation[quit]", + "eval.tests.test_interactive.test_save_log_records_prompt_and_response_interactive", + "eval.tests.test_loading.test_clean_load_failure_shows_press_any_key", + "eval.tests.test_loading.test_help_flag_reports_usage", + "eval.tests.test_loading.test_hparams_echoed_on_stdout", + "eval.tests.test_loading.test_invalid_model_magic_not_accepted[-empty-file-exactly]", + "eval.tests.test_loading.test_invalid_model_magic_not_accepted[XXXX-bad-magic]", + "eval.tests.test_loading.test_missing_model_file_segfaults_deterministically", + "eval.tests.test_loading.test_relative_model_path_resolved_from_cwd", + "eval.tests.test_loading.test_save_log_side_effect", + "eval.tests.test_loading.test_valid_model_loads_and_streams_diagnostics", + "eval.tests.test_loading.test_version_flag_reports_version", + "eval.tests.test_mpt_special_tokens.test_both_special_tokens_in_one_prompt", + "eval.tests.test_mpt_special_tokens.test_mpt_model_dispatches_and_special_vocab_loads", + "eval.tests.test_mpt_special_tokens.test_prompt_without_special_token_still_tokenizes", + "eval.tests.test_mpt_special_tokens.test_repeated_special_token_each_counts_one", + "eval.tests.test_mpt_special_tokens.test_second_special_token_im_end_matches", + "eval.tests.test_mpt_special_tokens.test_special_mpt_prompt_overflows_and_reports", + "eval.tests.test_mpt_special_tokens.test_special_spliced_between_two_letters", + "eval.tests.test_mpt_special_tokens.test_special_token_branch_is_reproducible", + "eval.tests.test_mpt_special_tokens.test_special_token_collapses_to_single_token", + "eval.tests.test_mpt_special_tokens.test_special_token_surrounded_by_tokens", + "eval.tests.test_sampler_boundaries.test_repeat_penalty_above_one_changes_stream", + "eval.tests.test_sampler_boundaries.test_repeat_penalty_below_one_reproduces_exact_stream[penalty-half]", + "eval.tests.test_sampler_boundaries.test_repeat_penalty_below_one_reproduces_exact_stream[penalty-zero]", + "eval.tests.test_sampler_boundaries.test_repeat_penalty_identity_is_argmax", + "eval.tests.test_sampler_boundaries.test_zero_and_negative_temperature_accepted_and_exact[-3]", + "eval.tests.test_sampler_boundaries.test_zero_and_negative_temperature_accepted_and_exact[0.0]", + "eval.tests.test_sampler_boundaries.test_zero_and_negative_temperature_accepted_and_exact[0]", + "eval.tests.test_sampling.test_deterministic_stdout_across_runs", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[15]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[1]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[2]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[3]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[40]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[5]", + "eval.tests.test_sampling.test_generation_is_exactly_L_repeated_n_times[9]", + "eval.tests.test_sampling.test_nucleus_top_p_below_one_is_accepted[0.5]", + "eval.tests.test_sampling.test_nucleus_top_p_below_one_is_accepted[0.9]", + "eval.tests.test_sampling.test_nucleus_top_p_truncation_is_deterministic", + "eval.tests.test_sampling.test_repeat_penalty_one_matches_identity_stream", + "eval.tests.test_sampling.test_repeat_penalty_shifts_collapsed_stream_and_is_reproducible", + "eval.tests.test_sampling.test_sampler_is_deterministic_for_fixed_command", + "eval.tests.test_sampling.test_sampling_param_combo_exact_hparams", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra0]", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra1]", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra2]", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra3]", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra4]", + "eval.tests.test_sampling.test_sampling_scalar_boundaries_accepted[extra5]", + "eval.tests.test_sampling.test_save_log_contains_prompt_and_response_blocks", + "eval.tests.test_sampling.test_save_log_response_has_exact_body_no_trailing_newline", + "eval.tests.test_sampling.test_temperature_is_deterministic_and_accepted[0.1]", + "eval.tests.test_sampling.test_temperature_is_deterministic_and_accepted[0.9]", + "eval.tests.test_sampling.test_temperature_is_deterministic_and_accepted[2.5]", + "eval.tests.test_sampling.test_top_k_one_is_greedy_over_lls", + "eval.tests.test_sampling.test_top_k_values_all_run_to_completion[k16]", + "eval.tests.test_sampling.test_top_k_values_all_run_to_completion[k2]", + "eval.tests.test_sampling.test_top_k_values_all_run_to_completion[k5]", + "eval.tests.test_sampling.test_top_k_values_all_run_to_completion[k63]", + "eval.tests.test_sampling.test_top_p_one_keeps_full_window", + "eval.tests.test_template_config.test_load_json_missing_file_reports_error_and_continues_with_default", + "eval.tests.test_template_config.test_load_json_sets_prompt_and_reaches_generation", + "eval.tests.test_template_config.test_load_template_custom_prompt_exact_golden", + "eval.tests.test_template_config.test_load_template_missing_file_reverts_and_reports", + "eval.tests.test_template_config.test_load_template_placeholder_only_sets_empty_prefix_footer", + "eval.tests.test_template_config.test_response_wrap_tokens_prefixed_and_suffixed[<s>-</s>]", + "eval.tests.test_template_config.test_response_wrap_tokens_prefixed_and_suffixed[BEG-END]", + "eval.tests.test_template_config.test_response_wrap_tokens_prefixed_and_suffixed[[[[-]]]]", + "eval.tests.test_tokenization.test_apostrophe_contraction_prompt_tokenizes", + "eval.tests.test_tokenization.test_digit_run_adds_one_token_per_digit[123-3]", + "eval.tests.test_tokenization.test_digit_run_adds_one_token_per_digit[4567-4]", + "eval.tests.test_tokenization.test_digit_run_adds_one_token_per_digit[9-1]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[ ]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[0]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[9]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[A]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[a]", + "eval.tests.test_tokenization.test_each_single_vocab_char_contributes_one_token[z]", + "eval.tests.test_tokenization.test_empty_prompt_exact_token_count", + "eval.tests.test_tokenization.test_in_vocab_char_adds_exactly_one_token", + "eval.tests.test_tokenization.test_mixed_known_and_unknown_char_delta", + "eval.tests.test_tokenization.test_multiple_ascii_letters_add_linearly", + "eval.tests.test_tokenization.test_overflow_banner_exact_text", + "eval.tests.test_tokenization.test_overflow_exact_token_diagnostic", + "eval.tests.test_tokenization.test_prompt_word_counts_each_letter", + "eval.tests.test_tokenization.test_punctuation_regex_branch_fires", + "eval.tests.test_tokenization.test_token_count_grows_monotonically_with_length", + "eval.tests.test_tokenization.test_token_count_in_bounded_range", + "eval.tests.test_tokenization.test_token_count_reproducible_across_runs", + "eval.tests.test_tokenization.test_unknown_ascii_adds_zero_tokens", + "eval.tests.test_tokenization.test_unknown_char_emits_exact_token_diagnostic[^]", + "eval.tests.test_tokenization.test_unknown_char_emits_exact_token_diagnostic[`]", + "eval.tests.test_tokenization.test_unknown_char_emits_exact_token_diagnostic[|]", + "eval.tests.test_tokenization.test_whitespace_and_newline_prompt_tokenizes", + "eval.tests.test_tokenization_edges.test_contraction_includes_known_letters_and_apostrophe_unknown", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[apostrophe-s]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-d]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-dont]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-im]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-its]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-ll]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-re]", + "eval.tests.test_tokenization_edges.test_contraction_word_split_exact_counts[contraction-ve]", + "eval.tests.test_tokenization_edges.test_symbol_word_split_branch_exact_counts[punct-all-unknown]", + "eval.tests.test_tokenization_edges.test_symbol_word_split_branch_exact_counts[punct-braces-unknown]", + "eval.tests.test_tokenization_edges.test_symbol_word_split_branch_exact_counts[punct-colon-semis]", + "eval.tests.test_tokenization_edges.test_symbol_word_split_branch_exact_counts[punct-underscore-quote-unknown]", + "eval.tests.test_tokenization_edges.test_whitespace_branches_exact_counts[one-trailing-space]", + "eval.tests.test_tokenization_edges.test_whitespace_branches_exact_counts[trailing-newline-unknown]", + "eval.tests.test_tokenization_edges.test_whitespace_branches_exact_counts[trailing-tab-unknown]", + "eval.tests.test_tokenization_edges.test_whitespace_branches_exact_counts[two-leading-spaces]", + "eval.tests.test_tokenization_edges.test_whitespace_branches_exact_counts[two-trailing-spaces]", + "eval.tests.test_tokenization_multiclass.test_multi_class_prompt_exact_delta[alnum-then-digit each char]", + "eval.tests.test_tokenization_multiclass.test_multi_class_prompt_exact_delta[both-cases-digits-space-comma]", + "eval.tests.test_tokenization_multiclass.test_multi_class_prompt_exact_delta[contraction-space-digit]", + "eval.tests.test_tokenization_multiclass.test_multi_class_prompt_exact_delta[dot-letters-pattern]", + "eval.tests.test_tokenization_multiclass.test_multi_class_prompt_exact_delta[space-digit-symbol-letters]", + "eval.tests.test_tokenization_multiclass.test_unknown_char_mixed_with_known" + ] + } + }, + "commit": "e022976f04609fd7b6d7da06dfa92abfcb549acc", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.9682026681428497, + "eval_clean_hashes": [ + "3a006cd086018433a9a0c91fb24cd88304488fad8aafb5c83fb46557abc2bec6" + ], + "input_record": { + "commit": "e022976f04609fd7b6d7da06dfa92abfcb549acc", + "difficulty": "easy", + "difficulty_code_lines": 4647, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 4647, + "difficulty_runtime_deps": 1, + "difficulty_score": 1.9682026681428497, + "difficulty_test_code_lines": 0, + "full_name": "kuvaus/LlamaGPTJ-chat", + "input_joern_zip": "cpp_joern/kuvaus__LlamaGPTJ-chat.zip", + "joern_status": true, + "joern_time": 11.791956088040024, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "facebookresearch/fastText", + "rank": 168, + "similarity": 0.5378758907318115 + }, + { + "pb_fullname": "HaliteChallenge/Halite", + "rank": 263, + "similarity": 0.47377583384513855 + } + ], + "repo_path": "cpp/kuvaus__LlamaGPTJ-chat", + "source": "commit:e022976f04609fd7b6d7da06dfa92abfcb549acc", + "status": "done", + "url": "https://github.com/kuvaus/LlamaGPTJ-chat" + }, + "instance_id": "kuvaus__LlamaGPTJ-chat.e022976", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "kuvaus/LlamaGPTJ-chat" +} diff --git a/kuvaus--llamagptj-chat.e022976/tests/test.sh b/kuvaus--llamagptj-chat.e022976/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kuvaus--llamagptj-chat.e022976/tests/workspace.tar.gz b/kuvaus--llamagptj-chat.e022976/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0da64cb52175821c27e78c973c64a12bc3e2e3fd --- /dev/null +++ b/kuvaus--llamagptj-chat.e022976/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1c4f254ec47b34f6f4698f5ade51833c6b3e6ba41474c7ac4d86a4370283bf6 +size 19918 diff --git a/kxzk--scraping-with-rust.f0f9b04/environment/Dockerfile b/kxzk--scraping-with-rust.f0f9b04/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..fcda33d89c241f216a19bcd9780cea160ab7d8c3 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/environment/Dockerfile @@ -0,0 +1,59 @@ +FROM rust:1.97.1-bookworm +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kxzk--scraping-with-rust.f0f9b04/environment/download.sh b/kxzk--scraping-with-rust.f0f9b04/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..40770ff2e18b0c471d41e9e9d8e80713aa16c5f3 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/environment/download.sh @@ -0,0 +1,50 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym networked dependency prefetch stage. +# +# Sole job: prefetch every Cargo dependency needed by the offline build of the +# "hack-scraper" package so that build.sh can compile fully offline. This file +# is executed in source mode (`source /source_ro/download.sh`), so it must not +# `exit` in normal control flow and must keep exported variables in the shell. +# +# It never reads any repository file. The dependency manifest is generated here +# inline from the versions declared in hack-scraper/Cargo.toml so the prefetch +# resolves the exact same dependency graph that build.sh will compile. + +set -u + +# Point Cargo at a shared registry cache. download.sh populates it here; the +# offline build.sh reuses the same CARGO_HOME to find the prefetched crates. +export CARGO_HOME="${CARGO_HOME:-/usr/local/cargo}" + +# Fresh scratch directory for the generated, throwaway Cargo manifest. Placed +# under /tmp so download.sh stays fully standalone (no repo files touched). +SCRATCH="/tmp/pb_prefetch_rust" +rm -rf "$SCRATCH" +mkdir -p "$SCRATCH/hack-scraper/src" + +# --- Generate the inline manifest (mirrors hack-scraper/Cargo.toml) --- +cat > "$SCRATCH/hack-scraper/Cargo.toml" <<'EOF' +[package] +name = "hack-scraper" +version = "0.1.0" +edition = "2021" + +[dependencies] +reqwest = { version = "0.11", features = ["blocking"] } +scraper = "0.13.0" +prettytable-rs = "0.9.0" +EOF + +# Minimal stub so cargo sees a resolvable bin target; used only for `cargo fetch`. +cat > "$SCRATCH/hack-scraper/src/main.rs" <<'EOF' +fn main() {} +EOF + +# --- Prefetch the full transitive dependency graph into CARGO_HOME --- +cargo fetch --manifest-path "$SCRATCH/hack-scraper/Cargo.toml" +if [ "$?" -ne 0 ]; then + echo "download.sh: cargo fetch failed" >&2 + return 1 +fi + +echo "download.sh: dependency prefetch complete" diff --git a/kxzk--scraping-with-rust.f0f9b04/environment/executable b/kxzk--scraping-with-rust.f0f9b04/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..cce3ffb69d14ef31aad2978f9ab60f046c8fa364 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5be23aef9fb75c61b455460461da99424a601fe8a36ddcd0539b5136c8fcca36 +size 5532608 diff --git a/kxzk--scraping-with-rust.f0f9b04/environment/harbor_prepare_download_env.sh b/kxzk--scraping-with-rust.f0f9b04/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/environment/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kxzk--scraping-with-rust.f0f9b04/environment/workspace.tar.gz b/kxzk--scraping-with-rust.f0f9b04/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3b396f64ddb8e41cd07f5bcbc6fb8984bf6f4b9f --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7b75adcb09cea0c0537fb39c47c0c50a1509704f8d98d099df3bfcb8a3cba3af +size 5590 diff --git a/kxzk--scraping-with-rust.f0f9b04/instruction.md b/kxzk--scraping-with-rust.f0f9b04/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kxzk--scraping-with-rust.f0f9b04/solution/solve.sh b/kxzk--scraping-with-rust.f0f9b04/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kxzk--scraping-with-rust.f0f9b04/task.toml b/kxzk--scraping-with-rust.f0f9b04/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c2b7f39c713d33828fd3e63ae1b2e979f73ca31b --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kxzk--scraping-with-rust.f0f9b04" +description = "Synthetic ProgramGym cleanroom reconstruction task for kxzk/scraping-with-rust" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "rust"] + +[metadata] +source = "ProgramGym" +instance_id = "kxzk__scraping-with-rust.f0f9b04" +repository = "kxzk/scraping-with-rust" +commit = "f0f9b044c0f4707b8aad2058964890c8f6025947" +language = "rust" +difficulty = "easy" +difficulty_score = 0.24303804868629442 +test_branches = 1 +test_count = 120 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/Dockerfile b/kxzk--scraping-with-rust.f0f9b04/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..0134a64cf31409020689a99b234432f2b5f5f7fe --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM rust:1.97.1-bookworm +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --break-system-packages \ + --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/blobs/tests/generated_module_01.tar.gz b/kxzk--scraping-with-rust.f0f9b04/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7de324d00f216c890cef9088875c0147056432c0 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:14e602698a39ea08aaddb40160ca9b863192c6f50cb26e50635482bb4f3707ad +size 14343 diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/download.sh b/kxzk--scraping-with-rust.f0f9b04/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..40770ff2e18b0c471d41e9e9d8e80713aa16c5f3 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/download.sh @@ -0,0 +1,50 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym networked dependency prefetch stage. +# +# Sole job: prefetch every Cargo dependency needed by the offline build of the +# "hack-scraper" package so that build.sh can compile fully offline. This file +# is executed in source mode (`source /source_ro/download.sh`), so it must not +# `exit` in normal control flow and must keep exported variables in the shell. +# +# It never reads any repository file. The dependency manifest is generated here +# inline from the versions declared in hack-scraper/Cargo.toml so the prefetch +# resolves the exact same dependency graph that build.sh will compile. + +set -u + +# Point Cargo at a shared registry cache. download.sh populates it here; the +# offline build.sh reuses the same CARGO_HOME to find the prefetched crates. +export CARGO_HOME="${CARGO_HOME:-/usr/local/cargo}" + +# Fresh scratch directory for the generated, throwaway Cargo manifest. Placed +# under /tmp so download.sh stays fully standalone (no repo files touched). +SCRATCH="/tmp/pb_prefetch_rust" +rm -rf "$SCRATCH" +mkdir -p "$SCRATCH/hack-scraper/src" + +# --- Generate the inline manifest (mirrors hack-scraper/Cargo.toml) --- +cat > "$SCRATCH/hack-scraper/Cargo.toml" <<'EOF' +[package] +name = "hack-scraper" +version = "0.1.0" +edition = "2021" + +[dependencies] +reqwest = { version = "0.11", features = ["blocking"] } +scraper = "0.13.0" +prettytable-rs = "0.9.0" +EOF + +# Minimal stub so cargo sees a resolvable bin target; used only for `cargo fetch`. +cat > "$SCRATCH/hack-scraper/src/main.rs" <<'EOF' +fn main() {} +EOF + +# --- Prefetch the full transitive dependency graph into CARGO_HOME --- +cargo fetch --manifest-path "$SCRATCH/hack-scraper/Cargo.toml" +if [ "$?" -ne 0 ]; then + echo "download.sh: cargo fetch failed" >&2 + return 1 +fi + +echo "download.sh: dependency prefetch complete" diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/executable b/kxzk--scraping-with-rust.f0f9b04/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..cce3ffb69d14ef31aad2978f9ab60f046c8fa364 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5be23aef9fb75c61b455460461da99424a601fe8a36ddcd0539b5136c8fcca36 +size 5532608 diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/harbor_prepare_download_env.sh b/kxzk--scraping-with-rust.f0f9b04/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/programgym_evaluator.py b/kxzk--scraping-with-rust.f0f9b04/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/programgym_task.json b/kxzk--scraping-with-rust.f0f9b04/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..f7e4e599ff8461b0d3fea09bfef531b337494741 --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/programgym_task.json @@ -0,0 +1,334 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_hn_fetch.test_exit_code_stays_nonsuccess_across_argument_shapes", + "reasons": [ + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_hn_fetch.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_hn_fetch.test_llvm_profile_var_appears_unchanged_in_child_environment", + "reasons": [ + { + "detail": "empty executable run failed as expected with returncode=1", + "id": "dummy_pass", + "message": "test passed against the empty executable", + "repair_hint": "Assert concrete black-box executable behavior so an empty executable cannot satisfy the test.", + "severity": "error", + "stage": "dummy_execution" + }, + { + "id": "if_else_both_assert", + "message": "pytest test asserts different outcomes in both if and else branches", + "path": "eval/tests/test_hn_fetch.py", + "repair_hint": "Remove nondeterministic branching and assert one deterministic expected behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_hn_fetch.test_llvm_profile_var_is_preserved_through_real_run", + "reasons": [ + { + "id": "if_else_both_assert", + "message": "pytest test asserts different outcomes in both if and else branches", + "path": "eval/tests/test_hn_fetch.py", + "repair_hint": "Remove nondeterministic branching and assert one deterministic expected behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_hn_fetch.test_no_proxy_panic_names_unwrap_site", + "reasons": [ + { + "id": "if_no_else", + "message": "pytest test has a conditional assertion with no else branch", + "path": "eval/tests/test_hn_fetch.py", + "repair_hint": "Add an else branch that fails, or assert the condition before making conditional checks.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_hn_fetch.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parse_render.test_golden_file_is_branch_local_and_real_sut_runs_empty", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parse_render.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parse_render.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_parse_render.test_golden_orders_title_before_href_for_each_story", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_parse_render.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_parse_render.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_hn_fetch.test_branch_root_executable_yields_real_contract", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_proxy_configuration[proxy_env0]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_proxy_configuration[proxy_env1]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_proxy_configuration[proxy_env2]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_proxy_configuration[proxy_env3]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_proxy_configuration[proxy_env4]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_rust_tooling_env[rust_env0]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_rust_tooling_env[rust_env1]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_rust_tooling_env[rust_env2]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_rust_tooling_env[rust_env3]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_tls_runtime_knobs[extra0]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_tls_runtime_knobs[extra1]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_tls_runtime_knobs[extra2]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_tls_runtime_knobs[extra3]", + "eval.tests.test_hn_fetch.test_contract_is_independent_of_tls_runtime_knobs[extra4]", + "eval.tests.test_hn_fetch.test_executable_is_a_regular_nonempty_file", + "eval.tests.test_hn_fetch.test_exit_code_stays_nonsuccess_across_argument_shapes", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv0]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv10]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv11]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv12]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv13]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv1]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv2]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv3]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv4]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv5]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv6]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv7]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv8]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[plain-argv9]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv0]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv10]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv11]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv12]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv13]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv1]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv2]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv3]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv4]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv5]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv6]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv7]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv8]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[spaces-argv9]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv0]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv10]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv11]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv12]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv13]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv1]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv2]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv3]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv4]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv5]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv6]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv7]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv8]", + "eval.tests.test_hn_fetch.test_failed_fetch_contract_ignores_argv[unicode-argv9]", + "eval.tests.test_hn_fetch.test_failed_fetch_terminates_promptly", + "eval.tests.test_hn_fetch.test_failure_is_a_signal_not_a_clean_code", + "eval.tests.test_hn_fetch.test_llvm_profile_var_appears_unchanged_in_child_environment", + "eval.tests.test_hn_fetch.test_llvm_profile_var_is_preserved_through_real_run", + "eval.tests.test_hn_fetch.test_no_proxy_direct_attempt_panics_not_renders[no_proxy_env0]", + "eval.tests.test_hn_fetch.test_no_proxy_direct_attempt_panics_not_renders[no_proxy_env1]", + "eval.tests.test_hn_fetch.test_no_proxy_direct_attempt_panics_not_renders[no_proxy_env2]", + "eval.tests.test_hn_fetch.test_no_proxy_panic_names_unwrap_site", + "eval.tests.test_hn_fetch.test_piped_stdin_does_not_yield_a_rendered_table[<td>ignored</td><span><a>story</a></span>]", + "eval.tests.test_hn_fetch.test_piped_stdin_does_not_yield_a_rendered_table[Alpha\\nBeta\\n]", + "eval.tests.test_hn_fetch.test_piped_stdin_does_not_yield_a_rendered_table[item?id=1\\nitem?id=2\\nitem?id=3\\n]", + "eval.tests.test_hn_fetch.test_repeated_runs_are_byte_identical", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[binary]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[empty]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[html]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[large]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[login]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[many_rows]", + "eval.tests.test_hn_fetch.test_stdin_is_never_read_for_story_data[url]", + "eval.tests.test_hn_fetch.test_stdout_stderr_pipes_are_not_swapped", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[+------------------+]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[+-]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[Alpha]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[https://]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[item?id=]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[login]", + "eval.tests.test_parse_render.test_failed_fetch_never_emits_render_prefix[|]", + "eval.tests.test_parse_render.test_golden_contains_each_story_cell_text[Alpha]", + "eval.tests.test_parse_render.test_golden_contains_each_story_cell_text[Beta]", + "eval.tests.test_parse_render.test_golden_contains_each_story_cell_text[https://ex.io/a1]", + "eval.tests.test_parse_render.test_golden_contains_each_story_cell_text[item?id=7]", + "eval.tests.test_parse_render.test_golden_file_is_branch_local_and_real_sut_runs_empty", + "eval.tests.test_parse_render.test_golden_fixture_has_the_expected_row_count", + "eval.tests.test_parse_render.test_golden_orders_title_before_href_for_each_story", + "eval.tests.test_parse_render.test_live_pipeline_renders_golden_alpha_beta", + "eval.tests.test_parse_render.test_no_table_marker_appears_on_stdout_across_runs", + "eval.tests.test_parse_render.test_render_column_width_computation_not_reached_without_fetch", + "eval.tests.test_parse_render.test_stdout_contains_no_prettytable_border_glyphs", + "eval.tests.test_reachability_robustness.test_concurrent_invocations_are_independent", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[color_force_off]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[home_missing]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[locale_tz]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[no_color_term]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[pager_less]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[proxy_env]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[ssl_cert_dir_missing]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[ssl_cert_file_missing]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[term_dumb]", + "eval.tests.test_reachability_robustness.test_contract_unchanged_under_env_stressors[term_empty]", + "eval.tests.test_reachability_robustness.test_empty_working_directory_does_not_change_contract", + "eval.tests.test_reachability_robustness.test_never_emits_partial_table_prefix", + "eval.tests.test_reachability_robustness.test_no_successful_exit_ever_observed", + "eval.tests.test_reachability_robustness.test_outcome_is_independent_of_working_directory", + "eval.tests.test_reachability_robustness.test_process_is_reaped_after_self_termination", + "eval.tests.test_reachability_robustness.test_reduced_fd_limit_does_not_change_contract", + "eval.tests.test_reachability_robustness.test_sequential_batch_runs_share_no_state", + "eval.tests.test_reachability_robustness.test_signal_death_is_identical_exit_signal_across_runs", + "eval.tests.test_reachability_robustness.test_signal_death_is_stable_across_reexecutions[run0]", + "eval.tests.test_reachability_robustness.test_signal_death_is_stable_across_reexecutions[run1]", + "eval.tests.test_reachability_robustness.test_signal_death_is_stable_across_reexecutions[run2]", + "eval.tests.test_reachability_robustness.test_signal_death_is_stable_across_reexecutions[run3]", + "eval.tests.test_reachability_robustness.test_sigterm_handling_is_not_required_but_no_hang[nowait]", + "eval.tests.test_reachability_robustness.test_sigterm_handling_is_not_required_but_no_hang[wait1s]", + "eval.tests.test_reachability_robustness.test_standard_streams_left_clean_under_fd_stress", + "eval.tests.test_reachability_robustness.test_very_large_count_argv_is_ignored", + "eval.tests.test_reachability_robustness.test_very_large_single_argument_is_ignored", + "eval.tests.test_reachability_robustness.test_working_directory_full_of_story_html_does_not_change_contract" + ] + } + }, + "commit": "f0f9b044c0f4707b8aad2058964890c8f6025947", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 0.24303804868629442, + "eval_clean_hashes": [ + "5be23aef9fb75c61b455460461da99424a601fe8a36ddcd0539b5136c8fcca36" + ], + "input_record": { + "codeql_db_mb": 84.02, + "codeql_status": true, + "codeql_time": 48.753638870082796, + "commit": "f0f9b044c0f4707b8aad2058964890c8f6025947", + "commits": 17, + "contributors": 2, + "difficulty": "easy", + "difficulty_code_lines": 35, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 35, + "difficulty_runtime_deps": 4, + "difficulty_score": 0.24303804868629442, + "difficulty_test_code_lines": 93, + "full_name": "kxzk/scraping-with-rust", + "github_stars": 262, + "input_codeql_db": "rust_codeql/kxzk__scraping-with-rust", + "language": "rs", + "pb_match": [ + { + "pb_fullname": "Drew-Alleman/DataSurgeon", + "rank": 434, + "similarity": 0.5046982169151306 + }, + { + "pb_fullname": "Canop/rhit", + "rank": 749, + "similarity": 0.42557570338249207 + }, + { + "pb_fullname": "bensadeh/tailspin", + "rank": 853, + "similarity": 0.474799245595932 + }, + { + "pb_fullname": "Isona/dirble", + "rank": 760, + "similarity": 0.45104944705963135 + }, + { + "pb_fullname": "sirwart/ripsecrets", + "rank": 860, + "similarity": 0.4667471647262573 + }, + { + "pb_fullname": "mgdm/htmlq", + "rank": 819, + "similarity": 0.43995657563209534 + }, + { + "pb_fullname": "rochacbruno/marmite", + "rank": 328, + "similarity": 0.4486634135246277 + } + ], + "repo_age": 8.58, + "repo_path": "rust/kxzk__scraping-with-rust", + "rust_channel": "stable", + "rust_edition": "2021", + "rust_release_date": "2021-10-21", + "rust_version": "1.56.0", + "rust_version_source": "edition", + "source": "commit:f0f9b044c0f4707b8aad2058964890c8f6025947", + "status": "done", + "url": "https://github.com/kxzk/scraping-with-rust" + }, + "instance_id": "kxzk__scraping-with-rust.f0f9b04", + "language": "rust", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "kxzk/scraping-with-rust" +} diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/test.sh b/kxzk--scraping-with-rust.f0f9b04/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kxzk--scraping-with-rust.f0f9b04/tests/workspace.tar.gz b/kxzk--scraping-with-rust.f0f9b04/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3b396f64ddb8e41cd07f5bcbc6fb8984bf6f4b9f --- /dev/null +++ b/kxzk--scraping-with-rust.f0f9b04/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7b75adcb09cea0c0537fb39c47c0c50a1509704f8d98d099df3bfcb8a3cba3af +size 5590 diff --git a/kyclark--command-line-rust.10d98/environment/Dockerfile b/kyclark--command-line-rust.10d98/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..fcda33d89c241f216a19bcd9780cea160ab7d8c3 --- /dev/null +++ b/kyclark--command-line-rust.10d98/environment/Dockerfile @@ -0,0 +1,59 @@ +FROM rust:1.97.1-bookworm +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kyclark--command-line-rust.10d98/environment/download.sh b/kyclark--command-line-rust.10d98/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..2659a632d2e96a4a3ce96480cb9bd97799cbc220 --- /dev/null +++ b/kyclark--command-line-rust.10d98/environment/download.sh @@ -0,0 +1,62 @@ +#!/usr/bin/env bash +# ProgramGym download stage for kyclark/command-line-rust (target: wcr). +# +# This file is SOURCED (`source /source_ro/download.sh`) and must be source-safe: +# * never call `exit` in normal control flow +# * keep exported env vars in the current shell +# * not read any repository file (Cargo.toml/Cargo.lock/etc.) +# * perform no compile/build/test step -- only prefetch dependencies +# +# It generates a temporary Cargo manifest matching the 05_wcr crate and runs +# `cargo fetch` against it so the offline build.sh can run `cargo build --offline`. + +set -u + +if [ "${BASH_SOURCE[0]}" != "$0" ]; then + : +else + echo "download.sh must be sourced, not executed" >&2 + exit 1 +fi + +# Explicit, deterministic cargo home so download and build stages share the cache. +if [ -z "${CARGO_HOME:-}" ]; then + export CARGO_HOME="$HOME/.cargo" +fi +mkdir -p "$CARGO_HOME" + +# Temporary directory holding the generated manifest and a matching stub main.rs. +# Kept under the shared CARGO_HOME so it is writable in the read-only mount too. +_PB_TMP="${CARGO_HOME}/programgym-wcr-fetch" +rm -rf "$_PB_TMP" +mkdir -p "$_PB_TMP/src" + +# Generated manifest for the wcr crate (clap v4 derive + anyhow). All dependency +# information is inline; nothing is read from the mounted repository. +cat > "$_PB_TMP/Cargo.toml" <<'EOF' +[package] +name = "wcr" +version = "0.1.0" +edition = "2021" +authors = ["Ken Youens-Clark <kyclark@gmail.com>"] + +[dependencies] +anyhow = "1.0.79" +clap = { version = "4.5.0", features = ["derive"] } + +[dev-dependencies] +assert_cmd = "2.0.13" +predicates = "3.0.4" +pretty_assertions = "1.4.0" +rand = "0.8.5" +EOF + +# Minimal stub main.rs so `cargo fetch` with the generated manifest succeeds. +cat > "$_PB_TMP/src/main.rs" <<'EOF' +fn main() {} +EOF + +# Prefetch all dependencies for the generated manifest. +cargo fetch --manifest-path "$_PB_TMP/Cargo.toml" + +echo "ProgramGym download stage complete: cargo deps prefetched into $CARGO_HOME" diff --git a/kyclark--command-line-rust.10d98/environment/executable b/kyclark--command-line-rust.10d98/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..71b1c3e71496f463a3ce8dcf03db20077ab77aab --- /dev/null +++ b/kyclark--command-line-rust.10d98/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16c30ce7120be56f4e58d0b47554ef8506f4d8df2b487eefa9581a81d43984a9 +size 1136232 diff --git a/kyclark--command-line-rust.10d98/environment/harbor_prepare_download_env.sh b/kyclark--command-line-rust.10d98/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kyclark--command-line-rust.10d98/environment/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kyclark--command-line-rust.10d98/environment/workspace.tar.gz b/kyclark--command-line-rust.10d98/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cf1c397b5e27f3f1f0bd11298b1bca19fcc86a1e --- /dev/null +++ b/kyclark--command-line-rust.10d98/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3646532f6e39d0a036ad126897051eb4f751d9cb30b11efcba3bb270811bf96b +size 3147 diff --git a/kyclark--command-line-rust.10d98/instruction.md b/kyclark--command-line-rust.10d98/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kyclark--command-line-rust.10d98/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kyclark--command-line-rust.10d98/solution/solve.sh b/kyclark--command-line-rust.10d98/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kyclark--command-line-rust.10d98/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kyclark--command-line-rust.10d98/task.toml b/kyclark--command-line-rust.10d98/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..41883df849850f5ad036e85fca3cc1ed71266562 --- /dev/null +++ b/kyclark--command-line-rust.10d98/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kyclark--command-line-rust.10d98" +description = "Synthetic ProgramGym cleanroom reconstruction task for kyclark/command-line-rust" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "rust"] + +[metadata] +source = "ProgramGym" +instance_id = "kyclark__command-line-rust.10d983f" +repository = "kyclark/command-line-rust" +commit = "10d983f68e84b9c94057da6ecf555bc419e11999" +language = "rust" +difficulty = "easy" +difficulty_score = 1.4196253608877432 +test_branches = 2 +test_count = 538 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kyclark--command-line-rust.10d98/tests/Dockerfile b/kyclark--command-line-rust.10d98/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..0134a64cf31409020689a99b234432f2b5f5f7fe --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM rust:1.97.1-bookworm +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV CARGO_HOME=/usr/local/cargo +ENV RUSTUP_HOME=/usr/local/rustup +ENV RUSTUP_TOOLCHAIN=1.97.1 +ENV PROGRAMGYM_RUST_TOOLCHAIN=1.97.1 +ENV PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends apt=2.6.1 bash=5.2.15-2+b13 build-essential=12.9 ca-certificates=20250419~deb12u1 cmake=3.25.1-1 git=1:2.39.5-0+deb12u3 make=4.3-4.1 pkg-config=1.8.1-1 python3=3.11.2-1+b1 python3-pip=23.0.1+dfsg-1 python3-dev=3.11.2-1+b1 autoconf=2.71-3 automake=1:1.16.5-1.3 gettext=0.21-12 file=1:5.44-3 binutils=2.40-2 libtool=2.4.7-7~deb12u1 libncurses-dev=6.4-4 meson=1.0.1-5 ninja-build=1.11.1-2~deb12u1 curl=7.88.1-10+deb12u15 wget=1.21.3-1+deb12u1 xz-utils=5.4.1-1+deb12u1 zstd=1.5.4+dfsg2-5 bzip2=1.0.8-5+b1 zip=3.0-13 unzip=6.0-28+deb12u1 patch=2.7.6-7 grep=3.8-5 python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +RUN rustup component add llvm-tools-preview --toolchain 1.97.1 +RUN RUST_SYSROOT="$(rustc --print sysroot)"; RUST_HOST="$(rustc -vV | sed -n 's/^host: //p')"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-profdata"; test -x "$RUST_SYSROOT/lib/rustlib/$RUST_HOST/bin/llvm-cov" +RUN rustc --version && cargo --version && rustup show active-toolchain +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /tmp/programgym-download.sh +RUN chmod 755 /tmp/programgym-download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /tmp/programgym-download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --break-system-packages \ + --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_01.tar.gz b/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ccb6d81535c2ea8978c6c6fdd2cce6e13d3bc7b0 --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85ac794c49fe2bbd371d1a52b4dd407f2410119d2a01141a7456e511ba2eb97d +size 14850 diff --git a/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_02.tar.gz b/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..55e10813ac8f675b6198920c3d2bd176fd770795 --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f17e8ae79b460ca9656bad3a56d347a1e480164f5c339f0e41e7bf5d235cf40 +size 27588 diff --git a/kyclark--command-line-rust.10d98/tests/download.sh b/kyclark--command-line-rust.10d98/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..2659a632d2e96a4a3ce96480cb9bd97799cbc220 --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/download.sh @@ -0,0 +1,62 @@ +#!/usr/bin/env bash +# ProgramGym download stage for kyclark/command-line-rust (target: wcr). +# +# This file is SOURCED (`source /source_ro/download.sh`) and must be source-safe: +# * never call `exit` in normal control flow +# * keep exported env vars in the current shell +# * not read any repository file (Cargo.toml/Cargo.lock/etc.) +# * perform no compile/build/test step -- only prefetch dependencies +# +# It generates a temporary Cargo manifest matching the 05_wcr crate and runs +# `cargo fetch` against it so the offline build.sh can run `cargo build --offline`. + +set -u + +if [ "${BASH_SOURCE[0]}" != "$0" ]; then + : +else + echo "download.sh must be sourced, not executed" >&2 + exit 1 +fi + +# Explicit, deterministic cargo home so download and build stages share the cache. +if [ -z "${CARGO_HOME:-}" ]; then + export CARGO_HOME="$HOME/.cargo" +fi +mkdir -p "$CARGO_HOME" + +# Temporary directory holding the generated manifest and a matching stub main.rs. +# Kept under the shared CARGO_HOME so it is writable in the read-only mount too. +_PB_TMP="${CARGO_HOME}/programgym-wcr-fetch" +rm -rf "$_PB_TMP" +mkdir -p "$_PB_TMP/src" + +# Generated manifest for the wcr crate (clap v4 derive + anyhow). All dependency +# information is inline; nothing is read from the mounted repository. +cat > "$_PB_TMP/Cargo.toml" <<'EOF' +[package] +name = "wcr" +version = "0.1.0" +edition = "2021" +authors = ["Ken Youens-Clark <kyclark@gmail.com>"] + +[dependencies] +anyhow = "1.0.79" +clap = { version = "4.5.0", features = ["derive"] } + +[dev-dependencies] +assert_cmd = "2.0.13" +predicates = "3.0.4" +pretty_assertions = "1.4.0" +rand = "0.8.5" +EOF + +# Minimal stub main.rs so `cargo fetch` with the generated manifest succeeds. +cat > "$_PB_TMP/src/main.rs" <<'EOF' +fn main() {} +EOF + +# Prefetch all dependencies for the generated manifest. +cargo fetch --manifest-path "$_PB_TMP/Cargo.toml" + +echo "ProgramGym download stage complete: cargo deps prefetched into $CARGO_HOME" diff --git a/kyclark--command-line-rust.10d98/tests/executable b/kyclark--command-line-rust.10d98/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..71b1c3e71496f463a3ce8dcf03db20077ab77aab --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16c30ce7120be56f4e58d0b47554ef8506f4d8df2b487eefa9581a81d43984a9 +size 1136232 diff --git a/kyclark--command-line-rust.10d98/tests/harbor_prepare_download_env.sh b/kyclark--command-line-rust.10d98/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a3a33381308d53b7bd2216a2375c8cd54ac24c4 --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/harbor_prepare_download_env.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail +command -v cargo +command -v rustc +command -v rustup +cd /workspace +set -a +source /tmp/programgym-download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kyclark--command-line-rust.10d98/tests/programgym_evaluator.py b/kyclark--command-line-rust.10d98/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kyclark--command-line-rust.10d98/tests/programgym_task.json b/kyclark--command-line-rust.10d98/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..32402585919bbb81662a8a1f3b87eb941cd6965a --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/programgym_task.json @@ -0,0 +1,815 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_counts.test_ascii_chars_equal_bytes", + "eval.tests.test_counts.test_byte_count_includes_newlines", + "eval.tests.test_counts.test_byte_count_no_trailing_newline", + "eval.tests.test_counts.test_byte_counts_ascii[-0]", + "eval.tests.test_counts.test_byte_counts_ascii[a-1]", + "eval.tests.test_counts.test_byte_counts_ascii[a\\n-2]", + "eval.tests.test_counts.test_byte_counts_ascii[a\\nb\\n-4]", + "eval.tests.test_counts.test_byte_counts_ascii[ab\\n-3]", + "eval.tests.test_counts.test_byte_counts_ascii[hello world\\n-12]", + "eval.tests.test_counts.test_chars_equals_bytes_for_plain_ascii_word_large", + "eval.tests.test_counts.test_crlf_line_ending", + "eval.tests.test_counts.test_crlf_words_rstrip_cr", + "eval.tests.test_counts.test_default_mode_reports_lines_words_bytes", + "eval.tests.test_counts.test_line_counts[-0]", + "eval.tests.test_counts.test_line_counts[\\n-1]", + "eval.tests.test_counts.test_line_counts[\\n\\n\\n-3]", + "eval.tests.test_counts.test_line_counts[a-1]", + "eval.tests.test_counts.test_line_counts[a\\n-1]", + "eval.tests.test_counts.test_line_counts[a\\n\\n\\n-3]", + "eval.tests.test_counts.test_line_counts[a\\nb\\n-2]", + "eval.tests.test_counts.test_line_counts[a\\nb\\nc\\n-3]", + "eval.tests.test_counts.test_lines_only_newlines", + "eval.tests.test_counts.test_no_trailing_newline_counts_as_line[-0]", + "eval.tests.test_counts.test_no_trailing_newline_counts_as_line[a b c-1]", + "eval.tests.test_counts.test_no_trailing_newline_counts_as_line[a-1]", + "eval.tests.test_counts.test_nonascii_word_count", + "eval.tests.test_counts.test_tab_counts_as_separator_not_word", + "eval.tests.test_counts.test_unicode_chars_vs_bytes[\\U0001f600\\n-2-5]", + "eval.tests.test_counts.test_unicode_chars_vs_bytes[\\u20ac\\n-2-4]", + "eval.tests.test_counts.test_unicode_chars_vs_bytes[\\xe9\\xe9\\n-3-5]", + "eval.tests.test_counts.test_unicode_chars_vs_bytes[caf\\xe9\\n-5-6]", + "eval.tests.test_counts.test_unicode_chars_vs_bytes[na\\xefve\\n-6-7]", + "eval.tests.test_counts.test_unicode_multibyte_chars_less_than_bytes", + "eval.tests.test_counts.test_word_counts[ -0]", + "eval.tests.test_counts.test_word_counts[ \\t\\n-0]", + "eval.tests.test_counts.test_word_counts[ leading and trailing -3]", + "eval.tests.test_counts.test_word_counts[-0]", + "eval.tests.test_counts.test_word_counts[\\n\\n-0]", + "eval.tests.test_counts.test_word_counts[a b c-3]", + "eval.tests.test_counts.test_word_counts[a b c-3]", + "eval.tests.test_counts.test_word_counts[a b-2]", + "eval.tests.test_counts.test_word_counts[a b\\nc d\\n-4]", + "eval.tests.test_counts.test_word_counts[a-1]", + "eval.tests.test_counts.test_word_counts[a\\tb\\nc-3]", + "eval.tests.test_counts.test_word_counts[hello\\nworld-2]", + "eval.tests.test_counts.test_word_counts[one\\ttwo three\\n-3]", + "eval.tests.test_counts.test_words_across_lines", + "eval.tests.test_counts.test_words_with_blank_lines_between", + "eval.tests.test_edge_cases.test_aggregate_mixes_stdin_and_file_totals", + "eval.tests.test_edge_cases.test_combined_flag_conflict_lines_bytes_chars", + "eval.tests.test_edge_cases.test_dash_amid_files", + "eval.tests.test_edge_cases.test_dash_row_has_no_filename", + "eval.tests.test_edge_cases.test_directory_as_only_argument_no_output", + "eval.tests.test_edge_cases.test_directory_total_contributes_zero", + "eval.tests.test_edge_cases.test_empty_file_among_many_zero_contrib", + "eval.tests.test_edge_cases.test_empty_path_with_valid_file_aggregate", + "eval.tests.test_edge_cases.test_empty_string_filename_errors", + "eval.tests.test_edge_cases.test_file_and_directory_no_total_error", + "eval.tests.test_edge_cases.test_file_with_only_whitespace_no_words", + "eval.tests.test_edge_cases.test_filename_with_weird_but_valid_name", + "eval.tests.test_edge_cases.test_invalid_utf8_bytes_produces_no_line[flag0]", + "eval.tests.test_edge_cases.test_invalid_utf8_bytes_produces_no_line[flag1]", + "eval.tests.test_edge_cases.test_invalid_utf8_bytes_produces_no_line[flag2]", + "eval.tests.test_edge_cases.test_invalid_utf8_bytes_produces_no_line[flag3]", + "eval.tests.test_edge_cases.test_invalid_utf8_bytes_produces_no_line[flag4]", + "eval.tests.test_edge_cases.test_invalid_utf8_stdin_bytes_count", + "eval.tests.test_edge_cases.test_invalid_utf8_via_stdin", + "eval.tests.test_edge_cases.test_moderate_input_sizes", + "eval.tests.test_edge_cases.test_same_file_repeat_accumulates_total", + "eval.tests.test_edge_cases.test_single_dash_reads_stdin", + "eval.tests.test_edge_cases.test_subdirectory_path_filename_rendering", + "eval.tests.test_edge_cases.test_symlink_file_reads_target_counts", + "eval.tests.test_edge_cases.test_three_unicode_files_byte_aggregate", + "eval.tests.test_edge_cases.test_three_unicode_files_char_aggregate", + "eval.tests.test_edge_cases.test_two_dashes_first_consumes_stdin", + "eval.tests.test_edge_cases.test_unicode_aggregate_chars_sum", + "eval.tests.test_edge_cases.test_unicode_aggregate_chars_total", + "eval.tests.test_edge_cases.test_unicode_aggregate_chars_total_is_bytes_distinct", + "eval.tests.test_files.test_empty_file_all_zero", + "eval.tests.test_files.test_empty_file_with_flag", + "eval.tests.test_files.test_file_bytes_only", + "eval.tests.test_files.test_file_chars_only", + "eval.tests.test_files.test_file_lines_only", + "eval.tests.test_files.test_file_words_only", + "eval.tests.test_files.test_many_files_all_total", + "eval.tests.test_files.test_missing_file_prints_error_to_stderr", + "eval.tests.test_files.test_missing_file_produces_no_stdout_line", + "eval.tests.test_files.test_missing_file_stderr_mentions_os_error", + "eval.tests.test_files.test_missing_then_present_skips_and_counts", + "eval.tests.test_files.test_no_total_for_stdin_only", + "eval.tests.test_files.test_present_then_missing", + "eval.tests.test_files.test_single_file_does_not_print_total", + "eval.tests.test_files.test_single_file_lines_words_bytes", + "eval.tests.test_files.test_single_file_prints_filename", + "eval.tests.test_files.test_single_file_unicode_counts", + "eval.tests.test_files.test_three_file_total_with_mixed_sizes", + "eval.tests.test_files.test_total_present_for_stdin_plus_file", + "eval.tests.test_files.test_total_uses_selected_fields_only", + "eval.tests.test_files.test_total_with_chars_flag", + "eval.tests.test_files.test_two_files_aggregate_total", + "eval.tests.test_files.test_two_files_identical_content_totals", + "eval.tests.test_flag_variants.test_all_three_order_variants", + "eval.tests.test_flag_variants.test_conflict_mixed_case_message", + "eval.tests.test_flag_variants.test_dash_as_file_arg_with_flags", + "eval.tests.test_flag_variants.test_default_and_flag_agree_on_single", + "eval.tests.test_flag_variants.test_flag_after_dash", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args0]", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args1]", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args2]", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args3]", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args4]", + "eval.tests.test_flag_variants.test_line_word_pair_order_independent[args5]", + "eval.tests.test_flag_variants.test_lines_with_empty_then_content", + "eval.tests.test_flag_variants.test_literal_dash_named_file_via_path_exists", + "eval.tests.test_flag_variants.test_literal_dash_named_file_via_path_missing", + "eval.tests.test_flag_variants.test_long_form_bytes_matches_short", + "eval.tests.test_flag_variants.test_long_form_chars_matches_short", + "eval.tests.test_flag_variants.test_long_form_lines_matches_short", + "eval.tests.test_flag_variants.test_long_form_words_matches_short", + "eval.tests.test_flag_variants.test_long_short_chars_bytes_conflict[args0]", + "eval.tests.test_flag_variants.test_long_short_chars_bytes_conflict[args1]", + "eval.tests.test_flag_variants.test_long_short_chars_bytes_conflict[args2]", + "eval.tests.test_flag_variants.test_punctuation_bytes_include_punctuation", + "eval.tests.test_flag_variants.test_punctuation_chars_equal_bytes_ascii", + "eval.tests.test_flag_variants.test_single_column_keeps_width8", + "eval.tests.test_flag_variants.test_three_column_output_has_two_width8_gaps", + "eval.tests.test_flag_variants.test_unicode_word_separators[ -0]", + "eval.tests.test_flag_variants.test_unicode_word_separators[-0]", + "eval.tests.test_flag_variants.test_unicode_word_separators[\\u65e5\\u672c\\u8a9e text-2]", + "eval.tests.test_flag_variants.test_unicode_word_separators[caf\\xe9 th\\xe9-2]", + "eval.tests.test_flag_variants.test_unicode_word_separators[caf\\xe9-1]", + "eval.tests.test_flag_variants.test_word_byte_pair_order_independent[args0]", + "eval.tests.test_flag_variants.test_word_byte_pair_order_independent[args1]", + "eval.tests.test_flag_variants.test_word_byte_pair_order_independent[args2]", + "eval.tests.test_flag_variants.test_word_byte_pair_order_independent[args3]", + "eval.tests.test_flag_variants.test_word_byte_pair_order_independent[args4]", + "eval.tests.test_flag_variants.test_word_separator_classes[\\tx\\t-1]", + "eval.tests.test_flag_variants.test_word_separator_classes[a,b;c:-1]", + "eval.tests.test_flag_variants.test_word_separator_classes[a-b-c-1]", + "eval.tests.test_flag_variants.test_word_separator_classes[a\\rb-2]", + "eval.tests.test_flag_variants.test_word_separator_classes[hello,world-1]", + "eval.tests.test_flag_variants.test_word_separator_classes[no_separators_here-1]", + "eval.tests.test_flag_variants.test_word_separator_classes[one\\ntwo-2]", + "eval.tests.test_flag_variants.test_word_separator_classes[x y-2]", + "eval.tests.test_flag_variants.test_words_over_multiple_lines", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args0---chars]", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args1---bytes]", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args2---chars]", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args3---bytes]", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args4---chars]", + "eval.tests.test_help_args.test_chars_and_bytes_conflict_exact[args5---bytes]", + "eval.tests.test_help_args.test_chars_bytes_conflict_full_message", + "eval.tests.test_help_args.test_combined_short_flag_with_chars", + "eval.tests.test_help_args.test_combined_short_flags_lines_words", + "eval.tests.test_help_args.test_combined_short_flags_words_bytes", + "eval.tests.test_help_args.test_default_file_is_stdin_empty", + "eval.tests.test_help_args.test_double_dash_between_two_files_aggregates", + "eval.tests.test_help_args.test_double_dash_makes_help_token_a_filename", + "eval.tests.test_help_args.test_double_dash_reads_dash_named_file", + "eval.tests.test_help_args.test_double_dash_then_literal_dash_uses_stdin", + "eval.tests.test_help_args.test_equals_flag_value_rejected[argv0-error: unexpected value '-c' for '--bytes' found; no more were expected\\n\\nUsage: <PROG> --bytes [FILE]...\\n\\nFor more information, try '--help'.\\n]", + "eval.tests.test_help_args.test_equals_flag_value_rejected[argv1-error: unexpected value '-l' for '--lines' found; no more were expected\\n\\nUsage: <PROG> --lines [FILE]...\\n\\nFor more information, try '--help'.\\n]", + "eval.tests.test_help_args.test_flags_after_positional_file", + "eval.tests.test_help_args.test_help_about_line_rust_wc", + "eval.tests.test_help_args.test_help_lists_bytes_flag_line", + "eval.tests.test_help_args.test_help_lists_chars_flag_line", + "eval.tests.test_help_args.test_help_lists_lines_flag_line", + "eval.tests.test_help_args.test_help_lists_words_flag_line", + "eval.tests.test_help_args.test_help_names_input_file_argument", + "eval.tests.test_help_args.test_help_prints_exact_usage", + "eval.tests.test_help_args.test_help_short_flag_prints_exact_usage", + "eval.tests.test_help_args.test_help_shows_default_stdin", + "eval.tests.test_help_args.test_long_flag_equals_with_positional", + "eval.tests.test_help_args.test_no_arguments_reads_stdin", + "eval.tests.test_help_args.test_positional_file_accepted_counts_only", + "eval.tests.test_help_args.test_repeated_flag_mixed_spelling_cannot_repeat", + "eval.tests.test_help_args.test_repeated_long_flag_cannot_be_used_multiple_times", + "eval.tests.test_help_args.test_unknown_flag_error_exact", + "eval.tests.test_help_args.test_unknown_flag_error_tips_help_full", + "eval.tests.test_help_args.test_unknown_short_flag_error_exact", + "eval.tests.test_help_args.test_unknown_short_in_combined_flags", + "eval.tests.test_help_args.test_version_long_flag_exact", + "eval.tests.test_help_args.test_version_short_flag_exact", + "eval.tests.test_output_format.test_bytes_only_shows_no_lines", + "eval.tests.test_output_format.test_chars_only_single_field", + "eval.tests.test_output_format.test_default_mode_replaces_missing_flags", + "eval.tests.test_output_format.test_field_exceeds_fixed_width[100000- 100000]", + "eval.tests.test_output_format.test_field_exceeds_fixed_width[1000000- 1000000]", + "eval.tests.test_output_format.test_field_width_scaling[1--l- 1]", + "eval.tests.test_output_format.test_field_width_scaling[10--l- 10]", + "eval.tests.test_output_format.test_field_width_scaling[100--l- 100]", + "eval.tests.test_output_format.test_field_width_scaling[1000--l- 1000]", + "eval.tests.test_output_format.test_field_width_scaling[10000--l- 10000]", + "eval.tests.test_output_format.test_fields_right_aligned_width8[a b c d e\\n--w-7]", + "eval.tests.test_output_format.test_fields_right_aligned_width8[a\\n--l-7]", + "eval.tests.test_output_format.test_fields_right_aligned_width8[hello\\n--c-7]", + "eval.tests.test_output_format.test_larger_value_width", + "eval.tests.test_output_format.test_line_field_width_eight", + "eval.tests.test_output_format.test_lines_and_words_no_bytes", + "eval.tests.test_output_format.test_lines_only_shows_no_words", + "eval.tests.test_output_format.test_literal_dash_uses_stdin_no_print", + "eval.tests.test_output_format.test_multiple_stdin_dash_and_file", + "eval.tests.test_output_format.test_named_file_appends_filename_with_space", + "eval.tests.test_output_format.test_order_lines_words_bytes_chars", + "eval.tests.test_output_format.test_order_with_chars_for_unicode", + "eval.tests.test_output_format.test_output_order_lines_words_bytes", + "eval.tests.test_output_format.test_plain_stdout_only_counts", + "eval.tests.test_output_format.test_single_default_flag_still_defaults_others", + "eval.tests.test_output_format.test_stdin_omits_filename", + "eval.tests.test_output_format.test_success_produces_no_stderr", + "eval.tests.test_output_format.test_words_and_bytes_only", + "eval.tests.test_output_format.test_words_only_shows_no_bytes" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_additional_surfaces.test_absolute_operand_path_echoed_verbatim", + "eval.tests.test_additional_surfaces.test_append_growth_changes_counts", + "eval.tests.test_additional_surfaces.test_combining_accent_counts_as_separate_scalar", + "eval.tests.test_additional_surfaces.test_dash_after_double_dash_is_stdin", + "eval.tests.test_additional_surfaces.test_dev_null_counts_zero", + "eval.tests.test_additional_surfaces.test_directory_among_valid_files_skips_only_the_dir", + "eval.tests.test_additional_surfaces.test_directory_containing_files_is_still_skipped", + "eval.tests.test_additional_surfaces.test_directory_operand_no_row", + "eval.tests.test_additional_surfaces.test_directory_with_trailing_slash_no_row", + "eval.tests.test_additional_surfaces.test_duplicate_flag_rejected_specific_message[bytes]", + "eval.tests.test_additional_surfaces.test_duplicate_flag_rejected_specific_message[chars_long]", + "eval.tests.test_additional_surfaces.test_duplicate_flag_rejected_specific_message[lines]", + "eval.tests.test_additional_surfaces.test_duplicate_flag_rejected_specific_message[words_long]", + "eval.tests.test_additional_surfaces.test_empty_file_chars_and_bytes_are_zero", + "eval.tests.test_additional_surfaces.test_empty_file_default_from_operand", + "eval.tests.test_additional_surfaces.test_fifo_operand_read_to_eof", + "eval.tests.test_additional_surfaces.test_flag_after_operand_plus_another_flag_total", + "eval.tests.test_additional_surfaces.test_flag_after_operand_selects_column", + "eval.tests.test_additional_surfaces.test_nested_relative_operand_path_echoed_verbatim", + "eval.tests.test_additional_surfaces.test_nul_bytes_are_not_line_terminators", + "eval.tests.test_additional_surfaces.test_short_V_version_flag_exact", + "eval.tests.test_additional_surfaces.test_short_h_and_long_help_stdout_identical", + "eval.tests.test_additional_surfaces.test_stdin_between_files_lines_only_total", + "eval.tests.test_additional_surfaces.test_stdin_place_between_files_operand_order_total", + "eval.tests.test_additional_surfaces.test_symlink_operand_follows_target_and_echoes_link", + "eval.tests.test_additional_surfaces.test_version_long_and_short_equal", + "eval.tests.test_additional_surfaces.test_zwj_family_emoji_chars_less_than_bytes", + "eval.tests.test_boundary.test_char_count_less_than_bytes_multibyte_stdin", + "eval.tests.test_boundary.test_char_count_matches_byte_count_for_ascii", + "eval.tests.test_boundary.test_double_dash_then_dash_named_file_is_file_not_flag", + "eval.tests.test_boundary.test_lines_and_chars_show_line_then_char", + "eval.tests.test_boundary.test_many_words_single_line", + "eval.tests.test_boundary.test_missing_dash_named_file_without_separator_is_flag_error", + "eval.tests.test_boundary.test_mixed_whitespace_separates_words", + "eval.tests.test_boundary.test_repeated_operand_counts_twice", + "eval.tests.test_boundary.test_single_tab_and_space_no_extra_word", + "eval.tests.test_boundary.test_template_of_words_with_trailing_space", + "eval.tests.test_boundary.test_whitespace_only_lines_contribute_zero_words", + "eval.tests.test_dash_and_longflags.test_chars_long_flag_reads_stdin_when_no_file", + "eval.tests.test_dash_and_longflags.test_chars_total_differs_from_bytes_total_on_multibyte", + "eval.tests.test_dash_and_longflags.test_dash_file_plus_plain_file_totals", + "eval.tests.test_dash_and_longflags.test_dash_flag_without_terminator_rejected", + "eval.tests.test_dash_and_longflags.test_dash_named_file_read_after_double_dash", + "eval.tests.test_dash_and_longflags.test_dash_named_file_still_diagnostics_for_missing", + "eval.tests.test_dash_and_longflags.test_default_stdin_when_flag_plus_no_operand_matches_file", + "eval.tests.test_dash_and_longflags.test_lines_long_flag_reads_stdin_when_no_file", + "eval.tests.test_dash_and_longflags.test_long_flags_all_three_together", + "eval.tests.test_dash_and_longflags.test_mixed_short_and_long_flags_agree", + "eval.tests.test_dash_and_longflags.test_two_column_combos_on_three_files_total[long_lw]", + "eval.tests.test_dash_and_longflags.test_two_column_combos_on_three_files_total[short_lc]", + "eval.tests.test_dash_and_longflags.test_two_column_combos_on_three_files_total[short_lw]", + "eval.tests.test_dash_and_longflags.test_words_plus_chars_needs_separate_runs_due_to_bytes_conflict", + "eval.tests.test_default_stdin.test_dash_among_files_counts_stdin_with_no_suffix", + "eval.tests.test_default_stdin.test_dash_operand_stdin_over_two_modes[dash_operand]", + "eval.tests.test_default_stdin.test_dash_operand_stdin_over_two_modes[no_files_default_stdin]", + "eval.tests.test_default_stdin.test_default_multiple_files_prints_total", + "eval.tests.test_default_stdin.test_default_single_file", + "eval.tests.test_default_stdin.test_default_stdin_empty", + "eval.tests.test_default_stdin.test_default_stdin_simple", + "eval.tests.test_default_stdin.test_default_stdin_single_word", + "eval.tests.test_default_stdin.test_stdin_crlf_counts_lines_and_bytes", + "eval.tests.test_default_stdin.test_stdin_embedded_tabs_as_whitespace", + "eval.tests.test_default_stdin.test_stdin_leading_trailing_whitespace_words", + "eval.tests.test_default_stdin.test_stdin_multibyte_utf8_bytes_greater_than_chars", + "eval.tests.test_default_stdin.test_stdin_only_newlines_no_words", + "eval.tests.test_default_stdin.test_stdin_single_line_no_trailing_newline", + "eval.tests.test_errors.test_all_operands_missing_still_emits_total", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[combined_mc]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[long_bytes_then_chars]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[long_chars_then_bytes]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[short_c_then_m]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[short_cm_with_file]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[short_m_then_c]", + "eval.tests.test_errors.test_chars_bytes_conflict_exits_2[short_mc_with_file]", + "eval.tests.test_errors.test_directory_operand_yields_no_row", + "eval.tests.test_errors.test_directory_plus_file_totals_only_valid", + "eval.tests.test_errors.test_empty_string_operand_mixed_with_valid_totals", + "eval.tests.test_errors.test_empty_string_operand_reports_blank_name_error", + "eval.tests.test_errors.test_file_that_reads_as_directory_branch_two_dirs", + "eval.tests.test_errors.test_flag_cluster_stops_at_first_unknown_short[cl-then-q]", + "eval.tests.test_errors.test_flag_cluster_stops_at_first_unknown_short[l-then-x]", + "eval.tests.test_errors.test_flag_cluster_stops_at_first_unknown_short[w-then-z]", + "eval.tests.test_errors.test_help_and_long_option_disagree_is_not_caught_by_short_flag", + "eval.tests.test_errors.test_help_flag_succeeds_and_documents_options", + "eval.tests.test_errors.test_invalid_utf8_file_mixed_with_valid_keeps_valid_row", + "eval.tests.test_errors.test_invalid_utf8_file_produces_no_row_and_no_diagnostic", + "eval.tests.test_errors.test_invalid_utf8_on_stdin_produces_no_output", + "eval.tests.test_errors.test_invalid_utf8_stdin_with_flag_still_no_output", + "eval.tests.test_errors.test_long_flag_value_assignment_rejected[bytes_eq]", + "eval.tests.test_errors.test_long_flag_value_assignment_rejected[lines_eq]", + "eval.tests.test_errors.test_long_flag_value_assignment_rejected[words_eq]", + "eval.tests.test_errors.test_missing_file_among_multiple_skips_but_totals", + "eval.tests.test_errors.test_missing_file_as_only_operand_stderr_is_exact_and_shows_path", + "eval.tests.test_errors.test_missing_file_reports_error_and_exits_zero", + "eval.tests.test_errors.test_missing_file_with_lines_flag_tail", + "eval.tests.test_errors.test_missing_value_for_short_flag_that_must_not_consume_next", + "eval.tests.test_errors.test_short_flag_equals_value_rejected[ch_eq]", + "eval.tests.test_errors.test_short_flag_equals_value_rejected[lines_eq_short]", + "eval.tests.test_errors.test_short_h_help_succeeds", + "eval.tests.test_errors.test_two_invalid_utf8_files_produce_only_zero_total", + "eval.tests.test_errors.test_unknown_flag_fails[long_unknown]", + "eval.tests.test_errors.test_unknown_flag_fails[short_unknown]", + "eval.tests.test_errors.test_unknown_flag_fails[with_valid_and_unknown]", + "eval.tests.test_errors.test_unreadable_file_skipped_with_diagnostic", + "eval.tests.test_errors.test_version_flag_succeeds", + "eval.tests.test_fixtures.test_afterline_counts_one_line_without_newline", + "eval.tests.test_fixtures.test_bytes_only[afterline.txt-counts5]", + "eval.tests.test_fixtures.test_bytes_only[crlf.txt-counts6]", + "eval.tests.test_fixtures.test_bytes_only[empty.txt-counts0]", + "eval.tests.test_fixtures.test_bytes_only[fox.txt-counts1]", + "eval.tests.test_fixtures.test_bytes_only[oneblank.txt-counts3]", + "eval.tests.test_fixtures.test_bytes_only[onlynewlines.txt-counts4]", + "eval.tests.test_fixtures.test_bytes_only[poem_one_line.txt-counts11]", + "eval.tests.test_fixtures.test_bytes_only[singlechar.txt-counts2]", + "eval.tests.test_fixtures.test_bytes_only[tabs.txt-counts7]", + "eval.tests.test_fixtures.test_bytes_only[three.txt-counts9]", + "eval.tests.test_fixtures.test_bytes_only[utf8.txt-counts8]", + "eval.tests.test_fixtures.test_bytes_only[whitespace.txt-counts10]", + "eval.tests.test_fixtures.test_chars_only[afterline.txt-counts5]", + "eval.tests.test_fixtures.test_chars_only[crlf.txt-counts6]", + "eval.tests.test_fixtures.test_chars_only[empty.txt-counts0]", + "eval.tests.test_fixtures.test_chars_only[fox.txt-counts1]", + "eval.tests.test_fixtures.test_chars_only[oneblank.txt-counts3]", + "eval.tests.test_fixtures.test_chars_only[onlynewlines.txt-counts4]", + "eval.tests.test_fixtures.test_chars_only[poem_one_line.txt-counts11]", + "eval.tests.test_fixtures.test_chars_only[singlechar.txt-counts2]", + "eval.tests.test_fixtures.test_chars_only[tabs.txt-counts7]", + "eval.tests.test_fixtures.test_chars_only[three.txt-counts9]", + "eval.tests.test_fixtures.test_chars_only[utf8.txt-counts8]", + "eval.tests.test_fixtures.test_chars_only[whitespace.txt-counts10]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[afterline.txt-counts5]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[crlf.txt-counts6]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[empty.txt-counts0]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[fox.txt-counts1]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[oneblank.txt-counts3]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[onlynewlines.txt-counts4]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[poem_one_line.txt-counts11]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[singlechar.txt-counts2]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[tabs.txt-counts7]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[three.txt-counts9]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[utf8.txt-counts8]", + "eval.tests.test_fixtures.test_default_counts_per_fixture[whitespace.txt-counts10]", + "eval.tests.test_fixtures.test_empty_file_all_zeros", + "eval.tests.test_fixtures.test_lines_only[afterline.txt-counts5]", + "eval.tests.test_fixtures.test_lines_only[crlf.txt-counts6]", + "eval.tests.test_fixtures.test_lines_only[empty.txt-counts0]", + "eval.tests.test_fixtures.test_lines_only[fox.txt-counts1]", + "eval.tests.test_fixtures.test_lines_only[oneblank.txt-counts3]", + "eval.tests.test_fixtures.test_lines_only[onlynewlines.txt-counts4]", + "eval.tests.test_fixtures.test_lines_only[poem_one_line.txt-counts11]", + "eval.tests.test_fixtures.test_lines_only[singlechar.txt-counts2]", + "eval.tests.test_fixtures.test_lines_only[tabs.txt-counts7]", + "eval.tests.test_fixtures.test_lines_only[three.txt-counts9]", + "eval.tests.test_fixtures.test_lines_only[utf8.txt-counts8]", + "eval.tests.test_fixtures.test_lines_only[whitespace.txt-counts10]", + "eval.tests.test_fixtures.test_utf8_bytes_exceeds_chars", + "eval.tests.test_fixtures.test_words_only[afterline.txt-counts5]", + "eval.tests.test_fixtures.test_words_only[crlf.txt-counts6]", + "eval.tests.test_fixtures.test_words_only[empty.txt-counts0]", + "eval.tests.test_fixtures.test_words_only[fox.txt-counts1]", + "eval.tests.test_fixtures.test_words_only[oneblank.txt-counts3]", + "eval.tests.test_fixtures.test_words_only[onlynewlines.txt-counts4]", + "eval.tests.test_fixtures.test_words_only[poem_one_line.txt-counts11]", + "eval.tests.test_fixtures.test_words_only[singlechar.txt-counts2]", + "eval.tests.test_fixtures.test_words_only[tabs.txt-counts7]", + "eval.tests.test_fixtures.test_words_only[three.txt-counts9]", + "eval.tests.test_fixtures.test_words_only[utf8.txt-counts8]", + "eval.tests.test_fixtures.test_words_only[whitespace.txt-counts10]", + "eval.tests.test_flags.test_all_three_default_flags[args0- 1 9 46\\n]", + "eval.tests.test_flags.test_all_three_default_flags[args1- 1 9 46\\n]", + "eval.tests.test_flags.test_all_three_default_flags[args2- 1 9 46\\n]", + "eval.tests.test_flags.test_all_three_default_flags[args3- 1 9 46\\n]", + "eval.tests.test_flags.test_bare_double_dash_means_no_flags", + "eval.tests.test_flags.test_duplicated_flag_in_group_is_rejected", + "eval.tests.test_flags.test_flag_order_preserves_fixed_column_layout_single_file", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args0- 1 9\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args1- 1 9\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args10- 1 9\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args11- 9 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args12- 1 9 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args2- 1 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args3- 1 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args4- 9 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args5- 9 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args6- 1 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args7- 9 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args8- 1 46\\n]", + "eval.tests.test_flags.test_pairs_of_flags_stdin[args9- 1 46\\n]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args0-lines-short_l]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args1-lines-long_lines]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args2-words-short_w]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args3-words-long_words]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args4-bytes-short_c]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args5-bytes-long_bytes]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args6-chars-short_m]", + "eval.tests.test_flags.test_single_flag_stdin_short_and_long[args7-chars-long_chars]", + "eval.tests.test_golden.test_fox_multicolumn_golden[-lc-l]", + "eval.tests.test_golden.test_fox_multicolumn_golden[-lm-l]", + "eval.tests.test_golden.test_fox_multicolumn_golden[-lw-l]", + "eval.tests.test_golden.test_fox_multicolumn_golden[-wc-w]", + "eval.tests.test_golden.test_fox_multicolumn_golden[-wm-w]", + "eval.tests.test_golden.test_multiple_file_totals_golden[default]", + "eval.tests.test_golden.test_multiple_file_totals_golden[lines]", + "eval.tests.test_golden.test_multiple_file_totals_golden[lm_chars]", + "eval.tests.test_golden.test_multiple_file_totals_golden[three_files]", + "eval.tests.test_golden.test_single_file_default_golden[a]", + "eval.tests.test_golden.test_single_file_default_golden[afterline]", + "eval.tests.test_golden.test_single_file_default_golden[b]", + "eval.tests.test_golden.test_single_file_default_golden[crlf]", + "eval.tests.test_golden.test_single_file_default_golden[empty]", + "eval.tests.test_golden.test_single_file_default_golden[fox]", + "eval.tests.test_golden.test_single_file_default_golden[one]", + "eval.tests.test_golden.test_single_file_default_golden[oneblank]", + "eval.tests.test_golden.test_single_file_default_golden[onlynewlines]", + "eval.tests.test_golden.test_single_file_default_golden[poem_one_line]", + "eval.tests.test_golden.test_single_file_default_golden[singlechar]", + "eval.tests.test_golden.test_single_file_default_golden[tabs]", + "eval.tests.test_golden.test_single_file_default_golden[three]", + "eval.tests.test_golden.test_single_file_default_golden[two]", + "eval.tests.test_golden.test_single_file_default_golden[utf8]", + "eval.tests.test_golden.test_single_file_default_golden[whitespace]", + "eval.tests.test_golden.test_single_file_each_column_golden[-c-c-crlf]", + "eval.tests.test_golden.test_single_file_each_column_golden[-c-c-empty]", + "eval.tests.test_golden.test_single_file_each_column_golden[-c-c-fox]", + "eval.tests.test_golden.test_single_file_each_column_golden[-c-c-utf8]", + "eval.tests.test_golden.test_single_file_each_column_golden[-l-l-crlf]", + "eval.tests.test_golden.test_single_file_each_column_golden[-l-l-empty]", + "eval.tests.test_golden.test_single_file_each_column_golden[-l-l-fox]", + "eval.tests.test_golden.test_single_file_each_column_golden[-l-l-utf8]", + "eval.tests.test_golden.test_single_file_each_column_golden[-m-m-crlf]", + "eval.tests.test_golden.test_single_file_each_column_golden[-m-m-empty]", + "eval.tests.test_golden.test_single_file_each_column_golden[-m-m-fox]", + "eval.tests.test_golden.test_single_file_each_column_golden[-m-m-utf8]", + "eval.tests.test_golden.test_single_file_each_column_golden[-w-w-crlf]", + "eval.tests.test_golden.test_single_file_each_column_golden[-w-w-empty]", + "eval.tests.test_golden.test_single_file_each_column_golden[-w-w-fox]", + "eval.tests.test_golden.test_single_file_each_column_golden[-w-w-utf8]", + "eval.tests.test_golden.test_stdin_golden_empty", + "eval.tests.test_golden.test_stdin_golden_hello", + "eval.tests.test_golden.test_stdin_golden_utf8_chars", + "eval.tests.test_iteration5_surfaces.test_crlf_cr_and_newline_both_counted_as_chars", + "eval.tests.test_iteration5_surfaces.test_crlf_multibyte_chars_diverge_from_bytes", + "eval.tests.test_iteration5_surfaces.test_crlf_only_blank_lines_zero_words_but_term_bytes_count", + "eval.tests.test_iteration5_surfaces.test_double_dash_named_file_read_after_terminator", + "eval.tests.test_iteration5_surfaces.test_double_dash_named_file_with_lines_only_flag", + "eval.tests.test_iteration5_surfaces.test_final_line_without_newline_counts_its_chars_and_bytes", + "eval.tests.test_iteration5_surfaces.test_lone_newline_is_one_char_and_one_line_zero_words", + "eval.tests.test_iteration5_surfaces.test_long_flag_named_file_read_after_terminator", + "eval.tests.test_iteration5_surfaces.test_lwm_char_column_differs_from_lwc_byte_column[short_lwc]", + "eval.tests.test_iteration5_surfaces.test_lwm_char_column_differs_from_lwc_byte_column[short_lwm]", + "eval.tests.test_iteration5_surfaces.test_lwm_char_column_differs_from_lwc_byte_column[spaced_lwc]", + "eval.tests.test_iteration5_surfaces.test_lwm_char_column_differs_from_lwc_byte_column[spaced_lwm]", + "eval.tests.test_iteration5_surfaces.test_lwm_char_count_reporting_still_counts_line_and_word_columns", + "eval.tests.test_iteration5_surfaces.test_lwm_total_across_multibyte_files", + "eval.tests.test_iteration5_surfaces.test_mixed_line_terminators_chars_equals_bytes_for_ascii", + "eval.tests.test_iteration5_surfaces.test_same_file_via_relative_and_absolute_operand_echoes_each", + "eval.tests.test_iteration5_surfaces.test_short_flag_named_file_read_after_terminator[short_c_file]", + "eval.tests.test_iteration5_surfaces.test_short_flag_named_file_read_after_terminator[short_l_file]", + "eval.tests.test_iteration5_surfaces.test_stdin_between_double_dash_named_files_produces_total", + "eval.tests.test_more_surfaces.test_bare_cr_bytes_count", + "eval.tests.test_more_surfaces.test_blank_lines_and_one_word_mixed", + "eval.tests.test_more_surfaces.test_bom_alone_no_newline_counts_one_char_three_bytes", + "eval.tests.test_more_surfaces.test_bom_between_words_is_own_word_token", + "eval.tests.test_more_surfaces.test_bom_line_counts_bytes_chars_words_lines", + "eval.tests.test_more_surfaces.test_bom_plus_two_words_default", + "eval.tests.test_more_surfaces.test_char_count_growth_on_append", + "eval.tests.test_more_surfaces.test_dev_fd_zero_operand_reads_stdin", + "eval.tests.test_more_surfaces.test_dev_null_and_real_file_totals", + "eval.tests.test_more_surfaces.test_dev_stdin_operand_bytes_flag", + "eval.tests.test_more_surfaces.test_dev_stdin_operand_chars_flag", + "eval.tests.test_more_surfaces.test_dev_stdin_operand_reads_stdin_and_echoes_name", + "eval.tests.test_more_surfaces.test_dev_stdin_plus_file_produces_total", + "eval.tests.test_more_surfaces.test_dot_among_files_skips_only_dir", + "eval.tests.test_more_surfaces.test_dot_dot_data_relative_operand_reads_file", + "eval.tests.test_more_surfaces.test_dot_operand_skipped", + "eval.tests.test_more_surfaces.test_double_dash_before_normal_file_reads_normally", + "eval.tests.test_more_surfaces.test_empty_among_many_files_zero_rows", + "eval.tests.test_more_surfaces.test_file_dash_file_three_way_bytes_flag", + "eval.tests.test_more_surfaces.test_long_single_word_byte_count", + "eval.tests.test_more_surfaces.test_many_blank_lines_bytes_exact", + "eval.tests.test_more_surfaces.test_many_blank_lines_exact_alignment", + "eval.tests.test_more_surfaces.test_many_blank_lines_words_is_zero", + "eval.tests.test_more_surfaces.test_many_single_char_lines_counts", + "eval.tests.test_more_surfaces.test_nul_stdin_chars_count", + "eval.tests.test_more_surfaces.test_nul_stdin_default", + "eval.tests.test_more_surfaces.test_parent_dir_operand_skipped", + "eval.tests.test_more_surfaces.test_single_byte_no_newline_file", + "eval.tests.test_more_surfaces.test_single_byte_no_newline_stdin", + "eval.tests.test_more_surfaces.test_single_space_line_default_counts", + "eval.tests.test_more_surfaces.test_two_dev_null_operands_yield_zero_total", + "eval.tests.test_multiple_files.test_bytes_total_across_multibyte_files", + "eval.tests.test_multiple_files.test_chars_total_across_multibyte_files", + "eval.tests.test_multiple_files.test_file_and_stdin_total_with_chars_flag", + "eval.tests.test_multiple_files.test_four_files_sum_each_default_column", + "eval.tests.test_multiple_files.test_lines_only_total_ignores_other_columns", + "eval.tests.test_multiple_files.test_single_file_emits_no_total_row", + "eval.tests.test_multiple_files.test_three_files_totals_sum_across_columns", + "eval.tests.test_multiple_files.test_three_identical_files_triple_each_value", + "eval.tests.test_multiple_files.test_total_with_lines_flag_only", + "eval.tests.test_multiple_files.test_total_with_words_line_counts", + "eval.tests.test_multiple_files.test_two_files_shows_total", + "eval.tests.test_multiple_files.test_two_stdin_dash_operands_total", + "eval.tests.test_multiple_files.test_words_total_across_three_files", + "eval.tests.test_word_and_char_edges.test_accented_chars_count_as_single_scalar", + "eval.tests.test_word_and_char_edges.test_consecutive_cr_only_is_whitespace_not_blank_lines", + "eval.tests.test_word_and_char_edges.test_del_is_not_whitespace_so_single_word", + "eval.tests.test_word_and_char_edges.test_emoji_chars_cols_less_than_bytes", + "eval.tests.test_word_and_char_edges.test_lone_cr_is_part_of_its_line_not_newline", + "eval.tests.test_word_and_char_edges.test_mixed_crlf_and_lf_line_terminators", + "eval.tests.test_word_and_char_edges.test_nbsp_chars_counted_as_one_scalar", + "eval.tests.test_word_and_char_edges.test_single_emoji_default_bytes_are_four_plus_newline", + "eval.tests.test_word_and_char_edges.test_trailing_whitespace_line_without_final_newline", + "eval.tests.test_word_and_char_edges.test_two_emoji_and_ascii_words_default", + "eval.tests.test_word_and_char_edges.test_whitespace_variants_for_word_splitting[bare_cr]", + "eval.tests.test_word_and_char_edges.test_whitespace_variants_for_word_splitting[control_only_lines]", + "eval.tests.test_word_and_char_edges.test_whitespace_variants_for_word_splitting[form_feed]", + "eval.tests.test_word_and_char_edges.test_whitespace_variants_for_word_splitting[nbsp]", + "eval.tests.test_word_and_char_edges.test_whitespace_variants_for_word_splitting[vertical_tab]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[arithmetic]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[blank_lines]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[blank_separator]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[currency]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[numbers]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[punct]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[sixteen_letters]", + "eval.tests.test_word_and_char_edges.test_word_tokenization_boundaries[symbols]" + ] + } + }, + "commit": "10d983f68e84b9c94057da6ecf555bc419e11999", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.4196253608877432, + "eval_clean_hashes": [ + "16c30ce7120be56f4e58d0b47554ef8506f4d8df2b487eefa9581a81d43984a9" + ], + "input_record": { + "codeql_db_mb": 84.43, + "codeql_status": true, + "codeql_time": 103.77522597741336, + "commit": "10d983f68e84b9c94057da6ecf555bc419e11999", + "commits": 221, + "contributors": 2, + "difficulty": "easy", + "difficulty_code_lines": 2628, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 2628, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.4196253608877432, + "difficulty_test_code_lines": 4357, + "full_name": "kyclark/command-line-rust", + "github_stars": 2016, + "input_codeql_db": "rust_codeql/kyclark__command-line-rust", + "language": "rs", + "pb_match": [ + { + "pb_fullname": "ducaale/xh", + "rank": 877, + "similarity": 0.4687034785747528 + }, + { + "pb_fullname": "Miserlou/Loop", + "rank": 537, + "similarity": 0.45462566614151 + }, + { + "pb_fullname": "sayanarijit/xplr", + "rank": 811, + "similarity": 0.5034036636352539 + }, + { + "pb_fullname": "alexpovel/srgn", + "rank": 845, + "similarity": 0.46948206424713135 + }, + { + "pb_fullname": "rvben/rumdl", + "rank": 557, + "similarity": 0.45651623606681824 + }, + { + "pb_fullname": "dandavison/delta", + "rank": 984, + "similarity": 0.4385944604873657 + }, + { + "pb_fullname": "sharkdp/hyperfine", + "rank": 540, + "similarity": 0.46828556060791016 + }, + { + "pb_fullname": "rust-lang/mdBook", + "rank": 256, + "similarity": 0.4981998801231384 + }, + { + "pb_fullname": "oppiliappan/statix", + "rank": 806, + "similarity": 0.4407273530960083 + }, + { + "pb_fullname": "sstadick/hck", + "rank": 368, + "similarity": 0.4547538161277771 + }, + { + "pb_fullname": "rust-embedded/svd2rust", + "rank": 204, + "similarity": 0.5412329435348511 + }, + { + "pb_fullname": "bensadeh/tailspin", + "rank": 941, + "similarity": 0.4696938693523407 + }, + { + "pb_fullname": "oppiliappan/eva", + "rank": 798, + "similarity": 0.45977193117141724 + }, + { + "pb_fullname": "WGUNDERWOOD/tex-fmt", + "rank": 513, + "similarity": 0.45650261640548706 + }, + { + "pb_fullname": "cordx56/rustowl", + "rank": 473, + "similarity": 0.6048477292060852 + }, + { + "pb_fullname": "o2sh/onefetch", + "rank": 712, + "similarity": 0.465878427028656 + }, + { + "pb_fullname": "sitkevij/hex", + "rank": 756, + "similarity": 0.4615600109100342 + }, + { + "pb_fullname": "ismaelgv/rnr", + "rank": 878, + "similarity": 0.3896358907222748 + }, + { + "pb_fullname": "nuta/nsh", + "rank": 726, + "similarity": 0.494060754776001 + }, + { + "pb_fullname": "wfxr/code-minimap", + "rank": 832, + "similarity": 0.5025951862335205 + }, + { + "pb_fullname": "riquito/tuc", + "rank": 728, + "similarity": 0.4208398759365082 + }, + { + "pb_fullname": "crowdagger/crowbook", + "rank": 211, + "similarity": 0.4652491509914398 + }, + { + "pb_fullname": "simeg/eureka", + "rank": 675, + "similarity": 0.47321105003356934 + }, + { + "pb_fullname": "Esubaalew/run", + "rank": 284, + "similarity": 0.5692522525787354 + }, + { + "pb_fullname": "clog-tool/clog-cli", + "rank": 742, + "similarity": 0.42391151189804077 + }, + { + "pb_fullname": "sigoden/argc", + "rank": 119, + "similarity": 0.5253802537918091 + }, + { + "pb_fullname": "ast-grep/ast-grep", + "rank": 475, + "similarity": 0.5315591096878052 + }, + { + "pb_fullname": "unhappychoice/gittype", + "rank": 712, + "similarity": 0.5126807689666748 + }, + { + "pb_fullname": "hush-shell/hush", + "rank": 454, + "similarity": 0.47355180978775024 + }, + { + "pb_fullname": "chmln/sd", + "rank": 775, + "similarity": 0.4576523005962372 + }, + { + "pb_fullname": "konradsz/igrep", + "rank": 996, + "similarity": 0.4530695676803589 + }, + { + "pb_fullname": "ecumene/rust-sloth", + "rank": 456, + "similarity": 0.48126253485679626 + }, + { + "pb_fullname": "pls-rs/pls", + "rank": 529, + "similarity": 0.44968730211257935 + }, + { + "pb_fullname": "mookid/diffr", + "rank": 997, + "similarity": 0.4604951739311218 + }, + { + "pb_fullname": "anordal/shellharden", + "rank": 845, + "similarity": 0.4607880115509033 + }, + { + "pb_fullname": "pier-cli/pier", + "rank": 845, + "similarity": 0.4890923798084259 + }, + { + "pb_fullname": "sharkdp/bat", + "rank": 685, + "similarity": 0.47819966077804565 + }, + { + "pb_fullname": "XAMPPRocky/tokei", + "rank": 285, + "similarity": 0.4639749526977539 + }, + { + "pb_fullname": "tree-sitter/tree-sitter", + "rank": 998, + "similarity": 0.43474116921424866 + }, + { + "pb_fullname": "yaa110/nomino", + "rank": 701, + "similarity": 0.4356774687767029 + } + ], + "repo_age": 6.41, + "repo_path": "rust/kyclark__command-line-rust", + "rust_channel": "stable", + "rust_edition": "2021", + "rust_release_date": "2021-10-21", + "rust_version": "1.56.0", + "rust_version_source": "edition", + "source": "commit:10d983f68e84b9c94057da6ecf555bc419e11999", + "status": "done", + "url": "https://github.com/kyclark/command-line-rust" + }, + "instance_id": "kyclark__command-line-rust.10d983f", + "language": "rust", + "module_iterations": [ + { + "actual_iterations": 3, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "kyclark/command-line-rust" +} diff --git a/kyclark--command-line-rust.10d98/tests/test.sh b/kyclark--command-line-rust.10d98/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kyclark--command-line-rust.10d98/tests/workspace.tar.gz b/kyclark--command-line-rust.10d98/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cf1c397b5e27f3f1f0bd11298b1bca19fcc86a1e --- /dev/null +++ b/kyclark--command-line-rust.10d98/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3646532f6e39d0a036ad126897051eb4f751d9cb30b11efcba3bb270811bf96b +size 3147 diff --git a/kylebanks--depth.5ba21c0/environment/Dockerfile b/kylebanks--depth.5ba21c0/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/kylebanks--depth.5ba21c0/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kylebanks--depth.5ba21c0/environment/download.sh b/kylebanks--depth.5ba21c0/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..7771445ea6685de454696a09faa597c7644530bf --- /dev/null +++ b/kylebanks--depth.5ba21c0/environment/download.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/KyleBanks/depth + +go 1.17 +PROGRAMGYM_GO_MOD_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +# No external Go module dependencies to prefetch. diff --git a/kylebanks--depth.5ba21c0/environment/executable b/kylebanks--depth.5ba21c0/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..915d303cf6031ceae31c5e3cd8899ffc9d436f80 --- /dev/null +++ b/kylebanks--depth.5ba21c0/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f55fac2fe61605e288bea63a0acf627305e65dfb898e0ba34a1ed2ca497f6f2 +size 4356527 diff --git a/kylebanks--depth.5ba21c0/environment/programgym-go.tar.gz b/kylebanks--depth.5ba21c0/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylebanks--depth.5ba21c0/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylebanks--depth.5ba21c0/environment/workspace.tar.gz b/kylebanks--depth.5ba21c0/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6ed3e95466676a19d0db02cc6d5f5742d67ae6fe --- /dev/null +++ b/kylebanks--depth.5ba21c0/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eea032ad0ec8f730e2bb3f67a58ac5bf10b7496b4f508bf25ba4190ed4b51f23 +size 2273 diff --git a/kylebanks--depth.5ba21c0/instruction.md b/kylebanks--depth.5ba21c0/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kylebanks--depth.5ba21c0/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kylebanks--depth.5ba21c0/solution/solve.sh b/kylebanks--depth.5ba21c0/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kylebanks--depth.5ba21c0/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kylebanks--depth.5ba21c0/task.toml b/kylebanks--depth.5ba21c0/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..224ef2e7764e07373e38a8a2955c274781a41e11 --- /dev/null +++ b/kylebanks--depth.5ba21c0/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kylebanks--depth.5ba21c0" +description = "Synthetic ProgramGym cleanroom reconstruction task for KyleBanks/depth" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "KyleBanks__depth.5ba21c0" +repository = "KyleBanks/depth" +commit = "5ba21c0383fd30d02fbd92d5f8e50ec8dd99d761" +language = "go" +difficulty = "easy" +difficulty_score = 0.6776069527204931 +test_branches = 3 +test_count = 293 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kylebanks--depth.5ba21c0/tests/Dockerfile b/kylebanks--depth.5ba21c0/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_01.tar.gz b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ddaae76731ed0346ac072c4d3b32fe4a35a5f798 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7a1e8b6aff25d90b01aef357841fa238eee9057c1e0b9e79805344b3ade9dd0 +size 6549 diff --git a/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_02.tar.gz b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..eeba788aac97ed8a582982b518a4160b53f24df9 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:400f00269eb6113bbe090c8861f1a7c6b70e77160250d0f485f7e4ccd02dc83e +size 14422 diff --git a/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_03.tar.gz b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..88262c8162f7d45b7d900c3be3e220f450ec756d --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a078a54025690870ec9d661db61dff786e1a839452d2e799fa045e1adb644dde +size 8348 diff --git a/kylebanks--depth.5ba21c0/tests/download.sh b/kylebanks--depth.5ba21c0/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..7771445ea6685de454696a09faa597c7644530bf --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/download.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/KyleBanks/depth + +go 1.17 +PROGRAMGYM_GO_MOD_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +# No external Go module dependencies to prefetch. diff --git a/kylebanks--depth.5ba21c0/tests/executable b/kylebanks--depth.5ba21c0/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..915d303cf6031ceae31c5e3cd8899ffc9d436f80 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f55fac2fe61605e288bea63a0acf627305e65dfb898e0ba34a1ed2ca497f6f2 +size 4356527 diff --git a/kylebanks--depth.5ba21c0/tests/programgym-go.tar.gz b/kylebanks--depth.5ba21c0/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylebanks--depth.5ba21c0/tests/programgym_evaluator.py b/kylebanks--depth.5ba21c0/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kylebanks--depth.5ba21c0/tests/programgym_task.json b/kylebanks--depth.5ba21c0/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..d903134217237060da222905fd37fcb603be2b5a --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/programgym_task.json @@ -0,0 +1,464 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_depth_cli.test_box_drawing_prefixes_nested_children", + "eval.tests.test_depth_cli.test_c_pseudo_package_is_empty", + "eval.tests.test_depth_cli.test_default_run_excludes_test_deps", + "eval.tests.test_depth_cli.test_explain_no_route_is_silent", + "eval.tests.test_depth_cli.test_explain_prints_many_reachable_paths", + "eval.tests.test_depth_cli.test_explain_single_path", + "eval.tests.test_depth_cli.test_explain_target_equals_root", + "eval.tests.test_depth_cli.test_external_stdlib_deps_marked_internal", + "eval.tests.test_depth_cli.test_failure_in_middle_stops_processing", + "eval.tests.test_depth_cli.test_flags_after_positional_treated_as_package", + "eval.tests.test_depth_cli.test_help_lists_flag_descriptions", + "eval.tests.test_depth_cli.test_help_prints_usage_to_stderr[--help]", + "eval.tests.test_depth_cli.test_help_prints_usage_to_stderr[-h]", + "eval.tests.test_depth_cli.test_json_and_test_combined", + "eval.tests.test_depth_cli.test_json_deps_sorted_internal_first", + "eval.tests.test_depth_cli.test_json_is_indented_two_spaces", + "eval.tests.test_depth_cli.test_json_omits_summary_line", + "eval.tests.test_depth_cli.test_json_output_is_valid_root_object", + "eval.tests.test_depth_cli.test_json_takes_precedence_over_explain", + "eval.tests.test_depth_cli.test_malformed_package_names_fatal[a/b/c/nope]", + "eval.tests.test_depth_cli.test_malformed_package_names_fatal[example.com/fake/module123]", + "eval.tests.test_depth_cli.test_malformed_package_names_fatal[github.com/does/not/exist_zz]", + "eval.tests.test_depth_cli.test_malformed_package_names_fatal[zz_no_such_pkg]", + "eval.tests.test_depth_cli.test_max_and_test_combined_limit_depth", + "eval.tests.test_depth_cli.test_max_depth_truncates_internal_tree", + "eval.tests.test_depth_cli.test_max_zero_means_unlimited", + "eval.tests.test_depth_cli.test_missing_flag_argument_exits_usage[-explain]", + "eval.tests.test_depth_cli.test_missing_flag_argument_exits_usage[-max]", + "eval.tests.test_depth_cli.test_multiple_packages_concatenate_output", + "eval.tests.test_depth_cli.test_no_arguments_is_a_noop", + "eval.tests.test_depth_cli.test_repeated_package_resolves_twice", + "eval.tests.test_depth_cli.test_summary_counts_deduplicate_across_tree", + "eval.tests.test_depth_cli.test_test_flag_adds_testing_dependencies", + "eval.tests.test_depth_cli.test_text_output_structure_and_summary_invariant", + "eval.tests.test_depth_cli.test_text_root_matches_requested_package", + "eval.tests.test_depth_cli.test_unknown_flag_exits_and_prints_usage", + "eval.tests.test_depth_cli.test_unresolvable_package_fatal_message" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_args.test_boolean_flags_explicit_value_accepted[-internal]", + "eval.tests.test_cli_args.test_boolean_flags_explicit_value_accepted[-test]", + "eval.tests.test_cli_args.test_equals_form_and_space_form_equivalent", + "eval.tests.test_cli_args.test_flag_after_positional_not_parsed", + "eval.tests.test_cli_args.test_help_flag_lists_options", + "eval.tests.test_cli_args.test_hex_max_accepted_as_large", + "eval.tests.test_cli_args.test_int_flag_consumes_next_token_as_value", + "eval.tests.test_cli_args.test_internal_explicit_true_expands_deps", + "eval.tests.test_cli_args.test_malformed_int_flag", + "eval.tests.test_cli_args.test_missing_value_for_int_flag", + "eval.tests.test_cli_args.test_no_args_exits_zero_no_output", + "eval.tests.test_cli_args.test_noninteger_max_rejected[-]", + "eval.tests.test_cli_args.test_noninteger_max_rejected[1.5]", + "eval.tests.test_cli_args.test_noninteger_max_rejected[12abc]", + "eval.tests.test_cli_args.test_noninteger_max_rejected[abc]", + "eval.tests.test_cli_args.test_test_and_internal_compose", + "eval.tests.test_cli_args.test_test_explicit_true_adds_testing_deps", + "eval.tests.test_cli_args.test_test_flag_adds_testing_deps", + "eval.tests.test_cli_args.test_unknown_flag_exits_2_with_usage", + "eval.tests.test_explain.test_explain_absent_target_no_output", + "eval.tests.test_explain.test_explain_default_internal_hidden", + "eval.tests.test_explain.test_explain_direct_dep_single_chain[errors]", + "eval.tests.test_explain.test_explain_direct_dep_single_chain[internal/bytealg]", + "eval.tests.test_explain.test_explain_direct_dep_single_chain[io]", + "eval.tests.test_explain.test_explain_direct_dep_single_chain[unicode/utf8]", + "eval.tests.test_explain.test_explain_direct_dep_single_chain[unsafe]", + "eval.tests.test_explain.test_explain_errors_root_transitive", + "eval.tests.test_explain.test_explain_internal_reveals_transitive_chains", + "eval.tests.test_explain.test_explain_multiple_roots_each_has_its_own_block", + "eval.tests.test_explain.test_explain_single_chain_format_for_direct_dep", + "eval.tests.test_import_cache.test_cache_lazy_initialization_behavior", + "eval.tests.test_import_cache.test_cyclic_import_handled_golang_org_vendor", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[fmt]", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[io]", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[os]", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[reflect]", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[regexp]", + "eval.tests.test_import_cache.test_deep_expansion_terminates_bounded[strings]", + "eval.tests.test_import_cache.test_internal_exact_flattened_total[bytes-39]", + "eval.tests.test_import_cache.test_internal_exact_flattened_total[errors-29]", + "eval.tests.test_import_cache.test_internal_exact_flattened_total[strings-39]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[fmt]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[io]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[os]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[reflect]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[regexp]", + "eval.tests.test_import_cache.test_shared_dep_printed_once_per_root[strings]", + "eval.tests.test_import_cache.test_unsafe_single_in_various_trees", + "eval.tests.test_internal.test_internal_boundary_max1_flat", + "eval.tests.test_internal.test_internal_exact_nested_dep_present", + "eval.tests.test_internal.test_internal_flag_all_still_internal[fmt]", + "eval.tests.test_internal.test_internal_flag_all_still_internal[os]", + "eval.tests.test_internal.test_internal_flag_all_still_internal[strings]", + "eval.tests.test_internal.test_internal_flag_increases_dep_count[fmt]", + "eval.tests.test_internal.test_internal_flag_increases_dep_count[io]", + "eval.tests.test_internal.test_internal_flag_increases_dep_count[os]", + "eval.tests.test_internal.test_internal_flag_increases_dep_count[reflect]", + "eval.tests.test_internal.test_internal_flag_increases_dep_count[strings]", + "eval.tests.test_internal.test_internal_flag_shows_nested_tree[fmt]", + "eval.tests.test_internal.test_internal_flag_shows_nested_tree[strings]", + "eval.tests.test_internal.test_without_internal_flat_top_level_only[fmt]", + "eval.tests.test_internal.test_without_internal_flat_top_level_only[strings]", + "eval.tests.test_internal.test_without_internal_mid_branch_present[fmt]", + "eval.tests.test_internal.test_without_internal_mid_branch_present[strings]", + "eval.tests.test_json.test_json_deps_internal_flag_from_shouldresolveinternal[fmt]", + "eval.tests.test_json.test_json_deps_internal_flag_from_shouldresolveinternal[strings]", + "eval.tests.test_json.test_json_internal_all_internal_true[fmt]", + "eval.tests.test_json.test_json_internal_all_internal_true[os]", + "eval.tests.test_json.test_json_internal_all_internal_true[strings]", + "eval.tests.test_json.test_json_internal_expands_deps[fmt]", + "eval.tests.test_json.test_json_internal_expands_deps[strings]", + "eval.tests.test_json.test_json_is_parseable_with_root[errors]", + "eval.tests.test_json.test_json_is_parseable_with_root[fmt]", + "eval.tests.test_json.test_json_is_parseable_with_root[io]", + "eval.tests.test_json.test_json_is_parseable_with_root[os]", + "eval.tests.test_json.test_json_is_parseable_with_root[sort]", + "eval.tests.test_json.test_json_is_parseable_with_root[strings]", + "eval.tests.test_json.test_json_max1_flat_leaf_deps[fmt]", + "eval.tests.test_json.test_json_max1_flat_leaf_deps[strings]", + "eval.tests.test_json.test_json_max_limits_deps[fmt-30]", + "eval.tests.test_json.test_json_max_limits_deps[strings-16]", + "eval.tests.test_json.test_json_preserves_sorted_order", + "eval.tests.test_json.test_json_unknown_root_still_fatal", + "eval.tests.test_maxdepth.test_max0_is_unlimited[fmt]", + "eval.tests.test_maxdepth.test_max0_is_unlimited[os]", + "eval.tests.test_maxdepth.test_max0_is_unlimited[strings]", + "eval.tests.test_maxdepth.test_max1_fmt_exact_count", + "eval.tests.test_maxdepth.test_max1_less_than_internal_limitless[fmt]", + "eval.tests.test_maxdepth.test_max1_less_than_internal_limitless[os]", + "eval.tests.test_maxdepth.test_max1_less_than_internal_limitless[strings]", + "eval.tests.test_maxdepth.test_max1_strings_flat_top_level", + "eval.tests.test_maxdepth.test_max_depth_exact_counts[errors-2-6]", + "eval.tests.test_maxdepth.test_max_depth_exact_counts[fmt-10-30]", + "eval.tests.test_maxdepth.test_max_depth_exact_counts[strings-11-16]", + "eval.tests.test_maxdepth.test_max_exact_full_equality_constant[fmt]", + "eval.tests.test_maxdepth.test_max_exact_full_equality_constant[os]", + "eval.tests.test_maxdepth.test_max_exact_full_equality_constant[strings]", + "eval.tests.test_maxdepth.test_max_increases_monotonically[fmt]", + "eval.tests.test_maxdepth.test_max_increases_monotonically[os]", + "eval.tests.test_maxdepth.test_max_increases_monotonically[strings]", + "eval.tests.test_maxdepth.test_max_large_equals_unlimited[fmt]", + "eval.tests.test_maxdepth.test_max_large_equals_unlimited[os]", + "eval.tests.test_maxdepth.test_max_large_equals_unlimited[strings]", + "eval.tests.test_maxdepth.test_max_negative_cuts_everything", + "eval.tests.test_resolve.test_resolve_c_cleanname_zero_deps", + "eval.tests.test_resolve.test_resolve_exact_dep_count[bytes-8]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[errors-2]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[io-2]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[math/bits-1]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[path-3]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[sort-3]", + "eval.tests.test_resolve.test_resolve_exact_dep_count[strings-11]", + "eval.tests.test_resolve.test_resolve_external_and_internal_split_absent_without_internal", + "eval.tests.test_resolve.test_resolve_repeated_invocation_identical[fmt]", + "eval.tests.test_resolve.test_resolve_repeated_invocation_identical[io]", + "eval.tests.test_resolve.test_resolve_repeated_invocation_identical[os]", + "eval.tests.test_resolve.test_resolve_repeated_invocation_identical[strings]", + "eval.tests.test_resolve.test_resolve_root_internal_flag", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[bytes]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[encoding/json]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[errors]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[fmt]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[io]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[math/bits]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[os]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[path/filepath]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[path]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[reflect]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[regexp]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[sort]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[strconv]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[strings]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[sync]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[testing]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[text/template]", + "eval.tests.test_resolve.test_resolve_success_root_name_and_zero_exit[time]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[bytes]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[encoding/json]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[errors]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[fmt]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[io]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[math/bits]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[os]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[path/filepath]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[path]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[reflect]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[regexp]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[sort]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[strconv]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[strings]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[sync]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[testing]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[text/template]", + "eval.tests.test_resolve.test_resolve_success_summary_internal[time]", + "eval.tests.test_resolve.test_resolve_zero_dep_root_succeeds[unicode/utf8]", + "eval.tests.test_resolve.test_resolve_zero_dep_root_succeeds[unicode]", + "eval.tests.test_resolve_errors.test_resolve_empty_string_arg_is_zero_dep_root", + "eval.tests.test_resolve_errors.test_resolve_multi_when_one_bad_errors_on_bad", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_fatal_and_exit_1[completelyboguspkgname]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_fatal_and_exit_1[example.com/definitely/not/a/real/package]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_fatal_and_exit_1[github.com/KyleBanks/depth/does/not/exist]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_fatal_and_exit_1[pkg/that/has/no/go/files]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_named_in_fatal[completelyboguspkgname]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_named_in_fatal[example.com/definitely/not/a/real/package]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_named_in_fatal[github.com/KyleBanks/depth/does/not/exist]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_named_in_fatal[pkg/that/has/no/go/files]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_no_summary[completelyboguspkgname]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_no_summary[example.com/definitely/not/a/real/package]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_no_summary[github.com/KyleBanks/depth/does/not/exist]", + "eval.tests.test_resolve_errors.test_resolve_unresolvable_root_no_summary[pkg/that/has/no/go/files]", + "eval.tests.test_resolve_multiple.test_cache_reset_between_roots_visible", + "eval.tests.test_resolve_multiple.test_multiple_roots_each_present[pkgs0]", + "eval.tests.test_resolve_multiple.test_multiple_roots_each_present[pkgs1]", + "eval.tests.test_resolve_multiple.test_multiple_roots_each_present[pkgs2]", + "eval.tests.test_resolve_multiple.test_multiple_roots_each_present[pkgs3]", + "eval.tests.test_resolve_multiple.test_multiple_roots_one_summary_each[pkgs0]", + "eval.tests.test_resolve_multiple.test_multiple_roots_one_summary_each[pkgs1]", + "eval.tests.test_resolve_multiple.test_multiple_roots_one_summary_each[pkgs2]", + "eval.tests.test_resolve_multiple.test_multiple_roots_one_summary_each[pkgs3]", + "eval.tests.test_resolve_multiple.test_multiple_roots_same_as_solo_blocks[pkgs0]", + "eval.tests.test_resolve_multiple.test_multiple_roots_same_as_solo_blocks[pkgs1]", + "eval.tests.test_resolve_multiple.test_multiple_roots_same_as_solo_blocks[pkgs2]", + "eval.tests.test_resolve_multiple.test_multiple_roots_same_as_solo_blocks[pkgs3]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_pkg_args_help.test_explain_direct_edge", + "eval.tests.test_pkg_args_help.test_explain_external_unresolved_dep", + "eval.tests.test_pkg_args_help.test_explain_internal_flag_path", + "eval.tests.test_pkg_args_help.test_explain_nested_via_dep", + "eval.tests.test_pkg_args_help.test_explain_not_found_empty", + "eval.tests.test_pkg_args_help.test_fatal_error_message_routing", + "eval.tests.test_pkg_args_help.test_help_short_h_flag", + "eval.tests.test_pkg_args_help.test_help_usage_lists_all_flags", + "eval.tests.test_pkg_args_help.test_json_only_output_is_valid_json", + "eval.tests.test_pkg_args_help.test_no_packages_exit_ok", + "eval.tests.test_pkg_args_help.test_unknown_flag_exit_2", + "eval.tests.test_pkg_json.test_json_cleanname_C_no_deps", + "eval.tests.test_pkg_json.test_json_deps_sorted_internal_first", + "eval.tests.test_pkg_json.test_json_external_dep_resolved_false", + "eval.tests.test_pkg_json.test_json_external_dep_sorted_last", + "eval.tests.test_pkg_json.test_json_internal_before_external_when_internals_precede", + "eval.tests.test_pkg_json.test_json_leaf_deps_null", + "eval.tests.test_pkg_json.test_json_mixed_externals_unresolved_and_sorted_last", + "eval.tests.test_pkg_json.test_json_nested_dep_graph_structure", + "eval.tests.test_pkg_json.test_json_root_internal_false_for_external_src", + "eval.tests.test_pkg_json.test_json_root_internal_flag[bytes]", + "eval.tests.test_pkg_json.test_json_root_internal_flag[errors]", + "eval.tests.test_pkg_json.test_json_root_internal_flag[strings]", + "eval.tests.test_pkg_json.test_json_root_internal_flag[unicode/utf8]", + "eval.tests.test_pkg_json.test_json_root_name_fixed[C-C]", + "eval.tests.test_pkg_json.test_json_root_name_fixed[errors-errors]", + "eval.tests.test_pkg_json.test_json_root_name_fixed[strings-strings]", + "eval.tests.test_pkg_json.test_json_root_name_fixed[unicode/utf8-unicode/utf8]", + "eval.tests.test_pkg_json.test_json_root_resolved_flag[bytes]", + "eval.tests.test_pkg_json.test_json_root_resolved_flag[errors]", + "eval.tests.test_pkg_json.test_json_root_resolved_flag[strings]", + "eval.tests.test_pkg_json.test_json_root_resolved_flag[unicode/utf8]", + "eval.tests.test_pkg_json.test_json_test_import_inclusion", + "eval.tests.test_pkg_resolve.test_cleanname_C_early_return", + "eval.tests.test_pkg_resolve.test_cleanname_golang_org_vendor_prefix", + "eval.tests.test_pkg_resolve.test_external_dep_internal_external_counts", + "eval.tests.test_pkg_resolve.test_external_dep_reported_unresolved", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[-1-flags4-strings-0 ]", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[0-flags0-strings-11 ]", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[1-flags1-strings-11 ]", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[1-flags5-errors-2 ]", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[100-flags3-strings-11 ]", + "eval.tests.test_pkg_resolve.test_max_depth_boundary[2-flags2-strings-16 ]", + "eval.tests.test_pkg_resolve.test_multiple_packages_resolved_in_order", + "eval.tests.test_pkg_resolve.test_resolve_default_no_internal_recursion", + "eval.tests.test_pkg_resolve.test_resolve_internal_resolves_deeper", + "eval.tests.test_pkg_resolve.test_resolve_no_test_by_default", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[bytes-names1]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[errors-names5]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[fmt-names2]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[math/bits-names4]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[sort-names3]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[strings-names0]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[time-names6]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_specific_deps[unicode/utf8-names7]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[bytes-8 dependencies (8 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[errors-2 dependencies (2 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[fmt-10 dependencies (10 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[math/bits-1 dependencies (1 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[sort-3 dependencies (3 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[strings-11 dependencies (11 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[time-9 dependencies (9 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_stdlib_summary[unicode/utf8-0 dependencies (0 internal, 0 external, 0 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_test_dedup_regular_and_test", + "eval.tests.test_pkg_resolve.test_resolve_test_imports[errors-8 dependencies (8 internal, 0 external, 6 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_test_imports[io-13 dependencies (13 internal, 0 external, 11 testing).]", + "eval.tests.test_pkg_resolve.test_resolve_test_imports[strings-20 dependencies (20 internal, 0 external, 9 testing).]", + "eval.tests.test_pkg_resolve.test_topologic_sort_internal_before_external_internals_alphabetically_early", + "eval.tests.test_pkg_resolve.test_topologic_sort_internal_first", + "eval.tests.test_pkg_resolve.test_topologic_sort_mixed_external_counts", + "eval.tests.test_pkg_resolve.test_topologic_sort_mixed_externals_report_unresolved", + "eval.tests.test_pkg_resolve.test_topologic_sort_multiple_externals_order_by_name", + "eval.tests.test_pkg_resolve.test_unknown_package_fatal" + ] + } + }, + "commit": "5ba21c0383fd30d02fbd92d5f8e50ec8dd99d761", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 0.6776069527204931, + "eval_clean_hashes": [ + "6f55fac2fe61605e288bea63a0acf627305e65dfb898e0ba34a1ed2ca497f6f2" + ], + "input_record": { + "commit": "5ba21c0383fd30d02fbd92d5f8e50ec8dd99d761", + "commits": 49, + "contributors": 5, + "difficulty": "easy", + "difficulty_code_lines": 476, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 476, + "difficulty_runtime_deps": 0, + "difficulty_score": 0.6776069527204931, + "difficulty_test_code_lines": 406, + "full_name": "KyleBanks/depth", + "github_stars": 1082, + "input_joern_zip": "go_joern/KyleBanks__depth.zip", + "joern_status": true, + "joern_time": 6.524588136002421, + "language": "go", + "pb_match": [ + { + "pb_fullname": "antonmedv/walk", + "rank": 637, + "similarity": 0.4748011827468872 + }, + { + "pb_fullname": "go-critic/go-critic", + "rank": 451, + "similarity": 0.539932370185852 + }, + { + "pb_fullname": "mibk/dupl", + "rank": 168, + "similarity": 0.579332709312439 + }, + { + "pb_fullname": "mgechev/revive", + "rank": 542, + "similarity": 0.5352573394775391 + }, + { + "pb_fullname": "mfridman/tparse", + "rank": 138, + "similarity": 0.5767697691917419 + }, + { + "pb_fullname": "gabotechs/dep-tree", + "rank": 3, + "similarity": 0.7152471542358398 + }, + { + "pb_fullname": "cweill/gotests", + "rank": 565, + "similarity": 0.5330625176429749 + }, + { + "pb_fullname": "jesseduffield/lazygit", + "rank": 961, + "similarity": 0.48263126611709595 + }, + { + "pb_fullname": "rs/jplot", + "rank": 371, + "similarity": 0.5198858976364136 + }, + { + "pb_fullname": "incu6us/goimports-reviser", + "rank": 78, + "similarity": 0.5669761300086975 + }, + { + "pb_fullname": "kyoh86/richgo", + "rank": 178, + "similarity": 0.5711601972579956 + }, + { + "pb_fullname": "psampaz/go-mod-outdated", + "rank": 5, + "similarity": 0.656330943107605 + }, + { + "pb_fullname": "kisielk/errcheck", + "rank": 623, + "similarity": 0.5451407432556152 + }, + { + "pb_fullname": "dundee/gdu", + "rank": 544, + "similarity": 0.49949565529823303 + }, + { + "pb_fullname": "tomnomnom/gron", + "rank": 498, + "similarity": 0.4932210445404053 + }, + { + "pb_fullname": "hairyhenderson/gomplate", + "rank": 680, + "similarity": 0.5156040787696838 + }, + { + "pb_fullname": "tomarrell/wrapcheck", + "rank": 435, + "similarity": 0.5196114778518677 + } + ], + "repo_age": 9.42, + "repo_path": "go/KyleBanks__depth", + "source": "commit:5ba21c0383fd30d02fbd92d5f8e50ec8dd99d761", + "status": "done", + "url": "https://github.com/KyleBanks/depth" + }, + "instance_id": "KyleBanks__depth.5ba21c0", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "KyleBanks/depth" +} diff --git a/kylebanks--depth.5ba21c0/tests/test.sh b/kylebanks--depth.5ba21c0/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kylebanks--depth.5ba21c0/tests/workspace.tar.gz b/kylebanks--depth.5ba21c0/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6ed3e95466676a19d0db02cc6d5f5742d67ae6fe --- /dev/null +++ b/kylebanks--depth.5ba21c0/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eea032ad0ec8f730e2bb3f67a58ac5bf10b7496b4f508bf25ba4190ed4b51f23 +size 2273 diff --git a/kylebanks--goggles.1811fc5/environment/Dockerfile b/kylebanks--goggles.1811fc5/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/kylebanks--goggles.1811fc5/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kylebanks--goggles.1811fc5/environment/download.sh b/kylebanks--goggles.1811fc5/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..46c94a90f300264ab3ded826229edb02b902ec1b --- /dev/null +++ b/kylebanks--goggles.1811fc5/environment/download.sh @@ -0,0 +1,79 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym download stage for KyleBanks/goggles (Go vendor-layout repo). +# +# This is a completely standalone single file. It is executed via +# source /source_ro/download.sh +# so it MUST be safe to source from a read-only repository mount while the +# container still has network access. It must not read any repository file and +# must not compile/link/test/package anything. +# +# It prefetches the pinned Go module dependencies of the product CLI ./cmd/goggles +# into the default module cache (which build.sh reuses offline), and exports the +# environment variables that build.sh relies on. +# +# The pins come from the repository's legacy GVP lockfile (lock.json), converted +# to Go module pseudo-versions, and are written inline here. Every dependency is +# stdlib-only in its own sources. +# +# NOTE: The module metadata embedded below (module path, go directive, require +# list, and go.sum) is verbatim identical to the metadata build.sh recreates at +# the repository root before the offline build. download.sh writes it to a fixed +# literal directory (not the repository) so nothing is read from the mounted +# source tree, and runs `go mod download -modfile=<generated absolute path>` to +# prefetch into the module cache. + +# Ensure the Go toolchain is discoverable by the offline build stage as well. +if command -v go; then + export PATH="$(dirname "$(command -v go)"):$PATH" +fi + +# Environment the offline build depends on (module mode; never touch the network, +# do no sumdb lookups). GOPROXY is left at the network default so the prefetch +# can reach the proxy; build.sh re-asserts GOPROXY=off for the offline build. +export GOFLAGS=-mod=mod +export GOSUMDB=off +export GONOSUMDB="*" + +# --------------------------------------------------------------------------- +# Prefetch dependencies. Generate the module metadata inline at a fixed literal +# directory. `go mod download` is invoked with an explicit literal absolute +# -modfile path that resolves to the inline-generated go.mod. +# --------------------------------------------------------------------------- +_PREFETCH_DIR="/tmp/programgym-goggles-prefetch" + +mkdir -p "$_PREFETCH_DIR" + +cat > "$_PREFETCH_DIR/go.mod" <<'MOD' +module github.com/KyleBanks/goggles + +go 1.20 + +require ( + github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf + github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de + github.com/elazarl/go-bindata-assetfs v1.0.0 + github.com/pkg/errors v0.8.0 + github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c +) +MOD + +cat > "$_PREFETCH_DIR/go.sum" <<'SUM' +github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf h1:u2fMXOOAB9DACAP+yTxOtAiC8DG7cU3LYPv/o4vBzj8= +github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE= +github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de h1:Bv+rkhI8c+aZts8jdXho8KAU4pvcYQwrBc0jj/PUFyo= +github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de/go.mod h1:Zf2kMqBfoYw8sdD+1XFrIcR9QWhnt6T+jTA7K97sIjU= +github.com/elazarl/go-bindata-assetfs v1.0.0 h1:G/bYguwHIzWq9ZoyUQqrjTmJbbYn3j3CKKpKinvZLFk= +github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4= +github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c h1:fyKiXKO1/I/B6Y2U8T7WdQGWzwehOuGIrljPtt7YTTI= +github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog= +SUM + +if ! (cd "$_PREFETCH_DIR" && go mod download -modfile="$_PREFETCH_DIR/go.mod"); then + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kylebanks--goggles.1811fc5/environment/executable b/kylebanks--goggles.1811fc5/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..43804ce3fcb27ca0d5f0561b78479322271396a8 --- /dev/null +++ b/kylebanks--goggles.1811fc5/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fce0fbf423764778c90727417e7a979f3eee9151a4920147d484a8636460b8a3 +size 11285244 diff --git a/kylebanks--goggles.1811fc5/environment/programgym-go.tar.gz b/kylebanks--goggles.1811fc5/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylebanks--goggles.1811fc5/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylebanks--goggles.1811fc5/environment/workspace.tar.gz b/kylebanks--goggles.1811fc5/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..897b23ed7e054dd7faf388140c2e9973703c7128 --- /dev/null +++ b/kylebanks--goggles.1811fc5/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c2dee6f29dde75813b90e8e581e8656711ca642ca0270dadab1dce1392c4e28a +size 5376957 diff --git a/kylebanks--goggles.1811fc5/instruction.md b/kylebanks--goggles.1811fc5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kylebanks--goggles.1811fc5/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kylebanks--goggles.1811fc5/solution/solve.sh b/kylebanks--goggles.1811fc5/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kylebanks--goggles.1811fc5/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kylebanks--goggles.1811fc5/task.toml b/kylebanks--goggles.1811fc5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e99161449f863e6b0ec0be8fb3f3b0048627028 --- /dev/null +++ b/kylebanks--goggles.1811fc5/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kylebanks--goggles.1811fc5" +description = "Synthetic ProgramGym cleanroom reconstruction task for KyleBanks/goggles" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "KyleBanks__goggles.1811fc5" +repository = "KyleBanks/goggles" +commit = "1811fc5e966c3768d0c38358b56bf0d246288ed8" +language = "go" +difficulty = "easy" +difficulty_score = 1.4207806195485655 +test_branches = 4 +test_count = 131 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kylebanks--goggles.1811fc5/tests/Dockerfile b/kylebanks--goggles.1811fc5/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_01.tar.gz b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2214ae7eef7d7a2bf483471f6f263b2ce6cd5ac2 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f994f336fcf47f53f646aa68850a7718afd31c4a89e2e1b3222463c73684dcf7 +size 7147 diff --git a/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_02.tar.gz b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c63c046d5cb8e6eedfef577922d62429703000af --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aee36987bf017059f73e4e6706438a7e346f3a989e79b2605006f543dd70e509 +size 20135 diff --git a/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_03.tar.gz b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6fb13401353965450b407c5520274b41bbcc51ba --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c79ecd5810bb26f87b2c9e92848671f9cdeb455e5656593913c149b8bcb71e8f +size 8812 diff --git a/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_04.tar.gz b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3459a5caf11d8bd6e47d7878e883534e3dd5e46d --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0e170c8d94a88ee9435a36230cbebea16100f28ae333fade63080569d02fe03 +size 4907 diff --git a/kylebanks--goggles.1811fc5/tests/download.sh b/kylebanks--goggles.1811fc5/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..46c94a90f300264ab3ded826229edb02b902ec1b --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/download.sh @@ -0,0 +1,79 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym download stage for KyleBanks/goggles (Go vendor-layout repo). +# +# This is a completely standalone single file. It is executed via +# source /source_ro/download.sh +# so it MUST be safe to source from a read-only repository mount while the +# container still has network access. It must not read any repository file and +# must not compile/link/test/package anything. +# +# It prefetches the pinned Go module dependencies of the product CLI ./cmd/goggles +# into the default module cache (which build.sh reuses offline), and exports the +# environment variables that build.sh relies on. +# +# The pins come from the repository's legacy GVP lockfile (lock.json), converted +# to Go module pseudo-versions, and are written inline here. Every dependency is +# stdlib-only in its own sources. +# +# NOTE: The module metadata embedded below (module path, go directive, require +# list, and go.sum) is verbatim identical to the metadata build.sh recreates at +# the repository root before the offline build. download.sh writes it to a fixed +# literal directory (not the repository) so nothing is read from the mounted +# source tree, and runs `go mod download -modfile=<generated absolute path>` to +# prefetch into the module cache. + +# Ensure the Go toolchain is discoverable by the offline build stage as well. +if command -v go; then + export PATH="$(dirname "$(command -v go)"):$PATH" +fi + +# Environment the offline build depends on (module mode; never touch the network, +# do no sumdb lookups). GOPROXY is left at the network default so the prefetch +# can reach the proxy; build.sh re-asserts GOPROXY=off for the offline build. +export GOFLAGS=-mod=mod +export GOSUMDB=off +export GONOSUMDB="*" + +# --------------------------------------------------------------------------- +# Prefetch dependencies. Generate the module metadata inline at a fixed literal +# directory. `go mod download` is invoked with an explicit literal absolute +# -modfile path that resolves to the inline-generated go.mod. +# --------------------------------------------------------------------------- +_PREFETCH_DIR="/tmp/programgym-goggles-prefetch" + +mkdir -p "$_PREFETCH_DIR" + +cat > "$_PREFETCH_DIR/go.mod" <<'MOD' +module github.com/KyleBanks/goggles + +go 1.20 + +require ( + github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf + github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de + github.com/elazarl/go-bindata-assetfs v1.0.0 + github.com/pkg/errors v0.8.0 + github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c +) +MOD + +cat > "$_PREFETCH_DIR/go.sum" <<'SUM' +github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf h1:u2fMXOOAB9DACAP+yTxOtAiC8DG7cU3LYPv/o4vBzj8= +github.com/KyleBanks/depth v0.0.0-20170325120045-5e7e54e3a9cf/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE= +github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de h1:Bv+rkhI8c+aZts8jdXho8KAU4pvcYQwrBc0jj/PUFyo= +github.com/KyleBanks/go-kit v0.0.0-20170324002555-a6154712f5de/go.mod h1:Zf2kMqBfoYw8sdD+1XFrIcR9QWhnt6T+jTA7K97sIjU= +github.com/elazarl/go-bindata-assetfs v1.0.0 h1:G/bYguwHIzWq9ZoyUQqrjTmJbbYn3j3CKKpKinvZLFk= +github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4= +github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c h1:fyKiXKO1/I/B6Y2U8T7WdQGWzwehOuGIrljPtt7YTTI= +github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog= +SUM + +if ! (cd "$_PREFETCH_DIR" && go mod download -modfile="$_PREFETCH_DIR/go.mod"); then + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kylebanks--goggles.1811fc5/tests/executable b/kylebanks--goggles.1811fc5/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..43804ce3fcb27ca0d5f0561b78479322271396a8 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fce0fbf423764778c90727417e7a979f3eee9151a4920147d484a8636460b8a3 +size 11285244 diff --git a/kylebanks--goggles.1811fc5/tests/programgym-go.tar.gz b/kylebanks--goggles.1811fc5/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylebanks--goggles.1811fc5/tests/programgym_evaluator.py b/kylebanks--goggles.1811fc5/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kylebanks--goggles.1811fc5/tests/programgym_task.json b/kylebanks--goggles.1811fc5/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..95476bedc700cac15fd4be88dd896d1cc0eba1a6 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/programgym_task.json @@ -0,0 +1,595 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-garbage=zzz&name=x]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-name=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-name=a-b-c]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-name=github.com-KyleBanks-goggles]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-url=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-url=example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-url=http:--example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer-url=https:--example.com-path-a=b&c=d]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-file-explorer<no-query>]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-garbage=zzz&name=x]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-name=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-name=a-b-c]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-name=github.com-KyleBanks-goggles]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-url=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-url=example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-url=http:--example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal-url=https:--example.com-path-a=b&c=d]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-terminal<no-query>]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-garbage=zzz&name=x]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-name=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-name=a-b-c]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-name=github.com-KyleBanks-goggles]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-url=]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-url=example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-url=http:--example.com]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url-url=https:--example.com-path-a=b&c=d]", + "eval.tests.test_api_open.test_open_action_returns_empty_object[-api-open-url<no-query>]", + "eval.tests.test_api_open.test_open_file_explorer_bare_path", + "eval.tests.test_api_open.test_open_terminal_bare_path", + "eval.tests.test_api_open.test_open_url_bare_path", + "eval.tests.test_api_pkgs.test_pkg_list_body_method_returns_json[DELETE]", + "eval.tests.test_api_pkgs.test_pkg_list_body_method_returns_json[GET]", + "eval.tests.test_api_pkgs.test_pkg_list_body_method_returns_json[POST]", + "eval.tests.test_api_pkgs.test_pkg_list_body_method_returns_json[PUT]", + "eval.tests.test_api_pkgs.test_pkg_list_empty_gopath_is_valid_json", + "eval.tests.test_api_pkgs.test_pkg_list_head_has_no_body", + "eval.tests.test_api_pkgs.test_pkg_list_no_redirection", + "eval.tests.test_api_pkgs.test_pkg_list_returns_http_200", + "eval.tests.test_api_preferences.test_get_preferences_gopath_not_empty", + "eval.tests.test_api_preferences.test_get_preferences_is_valid_config_json", + "eval.tests.test_api_preferences.test_get_preferences_returns_http_200", + "eval.tests.test_api_preferences.test_update_preferences_missing_gopath", + "eval.tests.test_api_preferences.test_update_preferences_returns_empty_object[/a/very/long/gopath/abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc]", + "eval.tests.test_api_preferences.test_update_preferences_returns_empty_object[/path/with spaces/config]", + "eval.tests.test_api_preferences.test_update_preferences_returns_empty_object[/tmp/programgym-custom-gopath]", + "eval.tests.test_api_preferences.test_update_preferences_returns_empty_object[]", + "eval.tests.test_api_preferences.test_update_then_get_reflects_gopath_change", + "eval.tests.test_static_assets.test_embedded_file_served[/static/css/colors.css-text/css]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/css/lib/milligram.min.css-text/css]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/css/lib/normalize.css-text/css]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/css/lib/prettify.css-text/css]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/css/main.css-text/css]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/img/loader-1.png-image/png]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/img/loader-2.png-image/png]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/img/loader-3.png-image/png]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/api.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/lib/prettify.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/lib/showdown.1.6.3.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/loader.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/pkg-details.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/pkg-list.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/preferences.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/state.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/template.js-text/javascript]", + "eval.tests.test_static_assets.test_embedded_file_served[/static/js/toast.js-text/javascript]", + "eval.tests.test_static_assets.test_index_html_follow_serves_html", + "eval.tests.test_static_assets.test_index_html_redirects_to_dot_slash", + "eval.tests.test_static_assets.test_main_css_has_body_content", + "eval.tests.test_static_assets.test_missing_static_directory_returns_404", + "eval.tests.test_static_assets.test_missing_static_file_returns_404", + "eval.tests.test_static_assets.test_prettify_js_served", + "eval.tests.test_static_assets.test_root_path_returns_404", + "eval.tests.test_static_assets.test_static_root_serves_embedded_index", + "eval.tests.test_static_assets.test_unknown_route_returns_404[/api/not-a-route]", + "eval.tests.test_static_assets.test_unknown_route_returns_404[/nope]", + "eval.tests.test_static_assets.test_unknown_route_returns_404[/not-existent.css]" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_resolver_hastravis.test_filtered_files_excluded_from_docs", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/feature: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_hastravis.test_filtered_name_matches_only_valid_source", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/feature: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "assertion_disjunction", + "message": "pytest assertion accepts alternatives with or", + "path": "eval/tests/test_resolver_hastravis.py", + "repair_hint": "Assert one exact expected outcome instead of accepting alternative outcomes with or.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_resolver_hastravis.test_travis_in_repository_root_is_true", + "reasons": [ + { + "detail": "AssertionError: details failed for github.com/acme/travisroot/lib: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_list.test_list_does_not_attach_docs", + "reasons": [ + { + "detail": "assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_list.test_list_entry_is_resolved", + "reasons": [ + { + "detail": "assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_list.test_list_is_sorted_lexicographically", + "reasons": [ + { + "detail": "assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_list.test_list_returns_every_fixture_package", + "reasons": [ + { + "detail": "assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_packagedoc.test_package_docs_deep_path", + "reasons": [ + { + "detail": "AssertionError: details failed for github.com/proj/group/deep/pkg: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_packagedoc.test_package_docs_header_and_declaration_blank", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/basic: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_packagedoc.test_package_docs_metadata", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/basic: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_packagedoc.test_package_usage_doc_comment", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/basic: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_constants_block_rendered", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/values: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_resolver_values.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_constants_followed_by_individual_const", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/values: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_multiple_constants_sorted_alphabetically", + "reasons": [ + { + "detail": "AssertionError: details failed for github.com/acme/travisroot/lib: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_no_constants_yields_empty_strings", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/basic: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_variable_groups_preserved", + "reasons": [ + { + "detail": "AssertionError: details failed for github.com/acme/travisroot/lib: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_resolver_values.test_variables_block_rendered", + "reasons": [ + { + "detail": "AssertionError: details failed for example.com/values: status 0 assert 0 == 200", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_resolver_values.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_resolver_edge_details.test_testdata_named_package_resolves_documentation", + "eval.tests.test_resolver_edge_details.test_testdata_package_function_content", + "eval.tests.test_resolver_edge_details.test_vendored_named_package_resolves_documentation", + "eval.tests.test_resolver_edge_details.test_vendored_package_function_and_travis", + "eval.tests.test_resolver_edge_details.test_vendored_package_repo_collapses_to_three_components", + "eval.tests.test_resolver_funcs_types.test_constructor_is_nested_under_type", + "eval.tests.test_resolver_funcs_types.test_deep_package_top_level_function", + "eval.tests.test_resolver_funcs_types.test_deep_package_type_has_method_content", + "eval.tests.test_resolver_funcs_types.test_function_usage_comment", + "eval.tests.test_resolver_funcs_types.test_package_function_with_receiver_on_package_content", + "eval.tests.test_resolver_funcs_types.test_simple_function_rendered", + "eval.tests.test_resolver_funcs_types.test_type_struct_declaration_rendered", + "eval.tests.test_resolver_funcs_types.test_unexported_function_is_not_documented", + "eval.tests.test_resolver_funcs_types.test_value_method_has_receiver_in_header", + "eval.tests.test_resolver_hastravis.test_filtered_files_excluded_from_docs", + "eval.tests.test_resolver_hastravis.test_filtered_name_matches_only_valid_source", + "eval.tests.test_resolver_hastravis.test_no_travis_is_false", + "eval.tests.test_resolver_hastravis.test_travis_in_package_dir_is_true", + "eval.tests.test_resolver_hastravis.test_travis_in_repository_root_is_true", + "eval.tests.test_resolver_list.test_list_does_not_attach_docs", + "eval.tests.test_resolver_list.test_list_entry_is_resolved", + "eval.tests.test_resolver_list.test_list_is_sorted_lexicographically", + "eval.tests.test_resolver_list.test_list_returns_every_fixture_package", + "eval.tests.test_resolver_packagedoc.test_package_docs_deep_path", + "eval.tests.test_resolver_packagedoc.test_package_docs_header_and_declaration_blank", + "eval.tests.test_resolver_packagedoc.test_package_docs_metadata", + "eval.tests.test_resolver_packagedoc.test_package_usage_doc_comment", + "eval.tests.test_resolver_values.test_constants_block_rendered", + "eval.tests.test_resolver_values.test_constants_followed_by_individual_const", + "eval.tests.test_resolver_values.test_multiple_constants_sorted_alphabetically", + "eval.tests.test_resolver_values.test_no_constants_yields_empty_strings", + "eval.tests.test_resolver_values.test_variable_groups_preserved", + "eval.tests.test_resolver_values.test_variables_block_rendered" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_server_api.test_preferences_update_logs_save_failure", + "reasons": [ + { + "detail": "AssertionError: expected conf.Save failure log from UpdatePreferences: 2026/09/04 06:41:40 v 2026/09/04 06:41:40 $GOPATH=[/a/gopath /b/gopath /c/gopath], srcdir=[/a/gopath/src /b/gopath/src /c/gopath/", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + } + ], + "tests": [ + "eval.tests.test_server_api.test_open_endpoint_returns_empty_json[file-explorer]", + "eval.tests.test_server_api.test_open_endpoint_returns_empty_json[terminal]", + "eval.tests.test_server_api.test_open_endpoint_returns_empty_json[url]", + "eval.tests.test_server_api.test_open_endpoint_with_missing_query_arg[file-explorer-empty]", + "eval.tests.test_server_api.test_open_endpoint_with_missing_query_arg[terminal-empty]", + "eval.tests.test_server_api.test_open_endpoint_with_missing_query_arg[url-empty]", + "eval.tests.test_server_api.test_pkg_list_route_is_wired", + "eval.tests.test_server_api.test_preferences_get_defaults", + "eval.tests.test_server_api.test_preferences_get_serialized_json_structure", + "eval.tests.test_server_api.test_preferences_route_redirects_trailing_slash", + "eval.tests.test_server_api.test_preferences_update_colon_separated_gopaths", + "eval.tests.test_server_api.test_preferences_update_logs_save_failure", + "eval.tests.test_server_api.test_preferences_update_single_gopath", + "eval.tests.test_server_api.test_root_route_returns_404", + "eval.tests.test_server_api.test_server_exits_nonzero_when_port_occupied", + "eval.tests.test_server_api.test_server_remains_alive_after_preferences_update", + "eval.tests.test_server_api.test_static_index_redirects_to_mount_root", + "eval.tests.test_server_api.test_unknown_route_returns_404", + "eval.tests.test_server_api.test_update_preferences_accepts_post_method", + "eval.tests.test_startup.test_startup_emits_version_line", + "eval.tests.test_startup.test_startup_reports_gopath_and_srcdir" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_module04_gopath.test_banner_reports_srcdir_consistent_with_gopath", + "eval.tests.test_module04_gopath.test_config_empty_gopath_uses_env", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[config_equals_env]", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[config_multi_split]", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[config_overrides_env]", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[config_wins_when_env_absent]", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[empty_config_uses_env]", + "eval.tests.test_module04_gopath.test_config_gopath_precedence[no_config_uses_env]", + "eval.tests.test_module04_gopath.test_config_wins_over_env_gopath_negative", + "eval.tests.test_module04_gopath.test_default_gopath_falls_back_to_home_dir", + "eval.tests.test_module04_gopath.test_double_colon_creates_empty_middle_gopath", + "eval.tests.test_module04_gopath.test_drive_colon_splits_path", + "eval.tests.test_module04_gopath.test_empty_string_gopath_defaults_to_home_dir", + "eval.tests.test_module04_gopath.test_leading_colon_creates_empty_first_gopath", + "eval.tests.test_module04_gopath.test_multi_gopath_each_srcdir_appended", + "eval.tests.test_module04_gopath.test_no_config_file_uses_env", + "eval.tests.test_module04_gopath.test_single_gopath_srcdir_appended", + "eval.tests.test_module04_gopath.test_startup_banner_is_well_formed", + "eval.tests.test_module04_gopath.test_trailing_colon_creates_empty_last_gopath" + ] + } + }, + "commit": "1811fc5e966c3768d0c38358b56bf0d246288ed8", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.4207806195485655, + "eval_clean_hashes": [ + "fce0fbf423764778c90727417e7a979f3eee9151a4920147d484a8636460b8a3" + ], + "input_record": { + "commit": "1811fc5e966c3768d0c38358b56bf0d246288ed8", + "commits": 58, + "contributors": 2, + "difficulty": "easy", + "difficulty_code_lines": 2635, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 2635, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.4207806195485655, + "difficulty_test_code_lines": 892, + "full_name": "KyleBanks/goggles", + "github_stars": 664, + "input_joern_zip": "go_joern/KyleBanks__goggles.zip", + "joern_status": true, + "joern_time": 5.54229603195563, + "language": "go", + "pb_match": [ + { + "pb_fullname": "antonmedv/walk", + "rank": 337, + "similarity": 0.5070568323135376 + }, + { + "pb_fullname": "mibk/dupl", + "rank": 485, + "similarity": 0.5373724699020386 + }, + { + "pb_fullname": "mgechev/revive", + "rank": 561, + "similarity": 0.5338382720947266 + }, + { + "pb_fullname": "alecthomas/chroma", + "rank": 599, + "similarity": 0.4756891131401062 + }, + { + "pb_fullname": "mfridman/tparse", + "rank": 430, + "similarity": 0.5336030721664429 + }, + { + "pb_fullname": "cweill/gotests", + "rank": 846, + "similarity": 0.5125911831855774 + }, + { + "pb_fullname": "jesseduffield/lazygit", + "rank": 318, + "similarity": 0.5452907085418701 + }, + { + "pb_fullname": "naggie/dstask", + "rank": 923, + "similarity": 0.465423583984375 + }, + { + "pb_fullname": "incu6us/goimports-reviser", + "rank": 737, + "similarity": 0.49056121706962585 + }, + { + "pb_fullname": "noborus/ov", + "rank": 713, + "similarity": 0.49768757820129395 + }, + { + "pb_fullname": "kyoh86/richgo", + "rank": 229, + "similarity": 0.5595757961273193 + }, + { + "pb_fullname": "eliukblau/pixterm", + "rank": 432, + "similarity": 0.5218029618263245 + }, + { + "pb_fullname": "TheZoraiz/ascii-image-converter", + "rank": 658, + "similarity": 0.47858673334121704 + }, + { + "pb_fullname": "cheat/cheat", + "rank": 842, + "similarity": 0.4872094988822937 + }, + { + "pb_fullname": "psampaz/go-mod-outdated", + "rank": 327, + "similarity": 0.4989631175994873 + }, + { + "pb_fullname": "dundee/gdu", + "rank": 657, + "similarity": 0.49084630608558655 + }, + { + "pb_fullname": "hairyhenderson/gomplate", + "rank": 863, + "similarity": 0.5076112151145935 + } + ], + "repo_age": 9.38, + "repo_path": "go/KyleBanks__goggles", + "source": "commit:1811fc5e966c3768d0c38358b56bf0d246288ed8", + "status": "done", + "url": "https://github.com/KyleBanks/goggles" + }, + "instance_id": "KyleBanks__goggles.1811fc5", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "KyleBanks/goggles" +} diff --git a/kylebanks--goggles.1811fc5/tests/test.sh b/kylebanks--goggles.1811fc5/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kylebanks--goggles.1811fc5/tests/workspace.tar.gz b/kylebanks--goggles.1811fc5/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..897b23ed7e054dd7faf388140c2e9973703c7128 --- /dev/null +++ b/kylebanks--goggles.1811fc5/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c2dee6f29dde75813b90e8e581e8656711ca642ca0270dadab1dce1392c4e28a +size 5376957 diff --git a/kylelemons--go-gypsy.95000da/environment/Dockerfile b/kylelemons--go-gypsy.95000da/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6f371332b0892136e00733449b81644d11444adf --- /dev/null +++ b/kylelemons--go-gypsy.95000da/environment/Dockerfile @@ -0,0 +1,58 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kylelemons--go-gypsy.95000da/environment/download.sh b/kylelemons--go-gypsy.95000da/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..fb0560876a6f5dc5d466c8e65d1339afec47fac9 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/environment/download.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kylelemons/go-gypsy + +go 1.5 +PROGRAMGYM_GO_MOD_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +# No external Go module dependencies to prefetch. diff --git a/kylelemons--go-gypsy.95000da/environment/executable b/kylelemons--go-gypsy.95000da/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..2b29a7b9d8786a92c8793ba2a90b7cc8adac447a --- /dev/null +++ b/kylelemons--go-gypsy.95000da/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85dc91de670a1cc28a0b61448c9d9a6af7e7f4e87d40caff8370f1e4976f9ba6 +size 2560526 diff --git a/kylelemons--go-gypsy.95000da/environment/programgym-go.tar.gz b/kylelemons--go-gypsy.95000da/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylelemons--go-gypsy.95000da/environment/workspace.tar.gz b/kylelemons--go-gypsy.95000da/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..be59a8f859e91017beb84ce25578a4562f713e8f --- /dev/null +++ b/kylelemons--go-gypsy.95000da/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:24b0c0df3baf20b3d74b7a5919a2f98335bf7333b97edf87711aef6a14a8a178 +size 1182 diff --git a/kylelemons--go-gypsy.95000da/instruction.md b/kylelemons--go-gypsy.95000da/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kylelemons--go-gypsy.95000da/solution/solve.sh b/kylelemons--go-gypsy.95000da/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kylelemons--go-gypsy.95000da/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kylelemons--go-gypsy.95000da/task.toml b/kylelemons--go-gypsy.95000da/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b930238bf5ec7ccd796ca48c852de281c8ebc2ef --- /dev/null +++ b/kylelemons--go-gypsy.95000da/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kylelemons--go-gypsy.95000da" +description = "Synthetic ProgramGym cleanroom reconstruction task for kylelemons/go-gypsy" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kylelemons__go-gypsy.95000da" +repository = "kylelemons/go-gypsy" +commit = "95000da7cfdd034f2a86bdd5e11df3372bae5c0d" +language = "go" +difficulty = "easy" +difficulty_score = 0.9642596301968491 +test_branches = 4 +test_count = 552 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kylelemons--go-gypsy.95000da/tests/Dockerfile b/kylelemons--go-gypsy.95000da/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..bd5f12bacd787ef39a90a560bc0dec968dcdb06e --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_01.tar.gz b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..a8fde66199ec29882aa363da02ac3f297468c901 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc38311c672af444f5eb958a50a8a046912dbe106424bb6bbc9257789e4af458 +size 15062 diff --git a/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_02.tar.gz b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..fed710894684ea3357cf2625a07ec5174c85f920 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1114008009d6d8a5a8dda6abdaf3df841ac6f99a895dc3615381fbf61cc61fa +size 17689 diff --git a/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_03.tar.gz b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b75c55a0be2cbb137e9234664cc1ca9181f187d1 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f07b5244ca75a10a5a91ed947d0047d954653d6555501882a9c19abfb795f0d2 +size 21496 diff --git a/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_04.tar.gz b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..93e3ee01825ad20a1e6add2f33c3c05323f9c2ef --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12947734942c3ca2383df5fdfea836821d4262c068813693d2d9c43d96dea4ea +size 10952 diff --git a/kylelemons--go-gypsy.95000da/tests/download.sh b/kylelemons--go-gypsy.95000da/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..fb0560876a6f5dc5d466c8e65d1339afec47fac9 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/download.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/kylelemons/go-gypsy + +go 1.5 +PROGRAMGYM_GO_MOD_EOF +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +# No external Go module dependencies to prefetch. diff --git a/kylelemons--go-gypsy.95000da/tests/executable b/kylelemons--go-gypsy.95000da/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..2b29a7b9d8786a92c8793ba2a90b7cc8adac447a --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85dc91de670a1cc28a0b61448c9d9a6af7e7f4e87d40caff8370f1e4976f9ba6 +size 2560526 diff --git a/kylelemons--go-gypsy.95000da/tests/programgym-go.tar.gz b/kylelemons--go-gypsy.95000da/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kylelemons--go-gypsy.95000da/tests/programgym_evaluator.py b/kylelemons--go-gypsy.95000da/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kylelemons--go-gypsy.95000da/tests/programgym_task.json b/kylelemons--go-gypsy.95000da/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..1137faed7ce34e84be6d327a85e7c0c219031966 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/programgym_task.json @@ -0,0 +1,663 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_block_scalar_parse.test_block_scalar_embedded_key_consumed_by_block", + "eval.tests.test_block_scalar_parse.test_block_scalar_indentation_stripped_from_each_line", + "eval.tests.test_block_scalar_parse.test_block_scalar_multiline", + "eval.tests.test_block_scalar_parse.test_block_scalar_single_line", + "eval.tests.test_block_scalar_parse.test_block_scalar_stops_at_blank_line", + "eval.tests.test_block_scalar_parse.test_block_scalar_then_next_key_same_indent", + "eval.tests.test_cli_entry.test_default_file_missing", + "eval.tests.test_cli_entry.test_explicit_file_flag_used", + "eval.tests.test_cli_entry.test_help_flag_lists_usage", + "eval.tests.test_cli_entry.test_missing_file_exits_nonzero", + "eval.tests.test_cli_entry.test_multiple_param_hits_and_misses", + "eval.tests.test_cli_entry.test_multiple_params_output_width_alignment", + "eval.tests.test_cli_entry.test_no_params_prints_nothing", + "eval.tests.test_cli_entry.test_value_starting_with_dash_becomes_list", + "eval.tests.test_example_config.test_example_admin_credentials", + "eval.tests.test_example_config.test_example_documented_lookups", + "eval.tests.test_example_config.test_example_mapping_and_list", + "eval.tests.test_example_config.test_example_out_of_range_admin", + "eval.tests.test_example_config.test_example_server_list_full", + "eval.tests.test_extra_grammar_edges.test_deep_inline_list_chain", + "eval.tests.test_extra_grammar_edges.test_empty_value_key_dropped", + "eval.tests.test_extra_grammar_edges.test_multiple_dashes_inline_sequence", + "eval.tests.test_extra_grammar_edges.test_nested_colon_space_splits_into_submapping", + "eval.tests.test_extra_grammar_edges.test_quoted_scalar_value_start_of_line", + "eval.tests.test_extra_grammar_edges.test_quoted_value_with_spaces", + "eval.tests.test_grammar_edges.test_colon_within_scalar_value", + "eval.tests.test_grammar_edges.test_deep_inline_chain", + "eval.tests.test_grammar_edges.test_inline_dash_value_is_sequence", + "eval.tests.test_grammar_edges.test_inline_map_then_nested_dash", + "eval.tests.test_grammar_edges.test_inline_nested_map_value", + "eval.tests.test_grammar_edges.test_key_charset[KeyName: value\\n-KeyName-value]", + "eval.tests.test_grammar_edges.test_key_charset[a-b: c\\n-a-b-c]", + "eval.tests.test_grammar_edges.test_key_charset[k1: v\\n-k1-v]", + "eval.tests.test_grammar_edges.test_key_charset[key2: w\\n-key2-w]", + "eval.tests.test_grammar_edges.test_key_charset[my_key: value\\n-my_key-value]", + "eval.tests.test_grammar_edges.test_map_inside_list_element", + "eval.tests.test_grammar_edges.test_multiple_colons_in_value", + "eval.tests.test_grammar_edges.test_url_as_scalar_value", + "eval.tests.test_grammar_edges.test_value_trailing_whitespace_preserved", + "eval.tests.test_grammar_edges.test_value_with_colon_space_splits_into_submapping", + "eval.tests.test_long_lines_and_blocks.test_block_scalar_at_deeper_indent", + "eval.tests.test_long_lines_and_blocks.test_block_scalar_followed_by_sibling_list", + "eval.tests.test_long_lines_and_blocks.test_consecutive_block_scalars", + "eval.tests.test_long_lines_and_blocks.test_inline_map_chain_value", + "eval.tests.test_long_lines_and_blocks.test_long_value_with_nested_content", + "eval.tests.test_long_lines_and_blocks.test_multiblock_with_blank_separation", + "eval.tests.test_long_lines_and_blocks.test_very_long_scalar_value_preserved", + "eval.tests.test_nested_structures.test_deep_missing_middle_map", + "eval.tests.test_nested_structures.test_deeply_nested_path", + "eval.tests.test_nested_structures.test_irregular_indentation_two_space_gap", + "eval.tests.test_nested_structures.test_list_of_maps_via_map_parent", + "eval.tests.test_nested_structures.test_map_of_lists", + "eval.tests.test_nested_structures.test_map_of_maps", + "eval.tests.test_nested_structures.test_multiple_top_level_maps", + "eval.tests.test_nested_structures.test_nested_key_reuse_across_maps", + "eval.tests.test_nested_structures.test_same_line_first_nested_key", + "eval.tests.test_parse_errors_and_format_edges.test_blank_and_comment_lines_inside_list", + "eval.tests.test_parse_errors_and_format_edges.test_blank_lines_within_mapping_preserve_keys", + "eval.tests.test_parse_errors_and_format_edges.test_comments_at_various_positions_ignored", + "eval.tests.test_parse_errors_and_format_edges.test_crlf_line_endings_accepted", + "eval.tests.test_parse_errors_and_format_edges.test_folded_greater_than_is_scalar_not_block", + "eval.tests.test_parse_errors_and_format_edges.test_iraspace_deep_gap_nesting", + "eval.tests.test_parse_errors_and_format_edges.test_list_of_lists_then_map_key_is_parse_error", + "eval.tests.test_parse_errors_and_format_edges.test_map_line_after_top_list_is_parse_error", + "eval.tests.test_parse_errors_and_format_edges.test_multiple_space_indentation_nests", + "eval.tests.test_parse_errors_and_format_edges.test_scalar_then_nested_key_is_parse_error", + "eval.tests.test_parse_errors_and_format_edges.test_tab_is_not_indentation", + "eval.tests.test_parse_errors_and_format_edges.test_tab_leading_key_is_top_level", + "eval.tests.test_parse_recovery_and_gettype.test_list_after_inline_map_value_panics", + "eval.tests.test_parse_recovery_and_gettype.test_list_after_top_level_map_panics", + "eval.tests.test_parse_recovery_and_gettype.test_quote_boundary_in_value_not_found", + "eval.tests.test_parse_recovery_and_gettype.test_quote_boundary_key_is_root_scalar", + "eval.tests.test_parse_recovery_and_gettype.test_quote_boundary_mid_scalar_line", + "eval.tests.test_parse_recovery_and_gettype.test_scalar_after_nested_list_panics", + "eval.tests.test_parse_recovery_and_gettype.test_scalar_after_top_level_list_panics", + "eval.tests.test_parse_recovery_and_gettype.test_scalar_after_top_level_map_panics", + "eval.tests.test_parse_recovery_and_gettype.test_scalar_onto_non_scalar_recovers_string_panic[a: 1\\nplain\\nb: 2\\n]", + "eval.tests.test_parse_recovery_and_gettype.test_scalar_onto_non_scalar_recovers_string_panic[k: v\\nhello\\n]", + "eval.tests.test_scalar_mapping_parse.test_comment_only_file_nil_root", + "eval.tests.test_scalar_mapping_parse.test_empty_file_nil_root_not_found", + "eval.tests.test_scalar_mapping_parse.test_implied_dot_selector", + "eval.tests.test_scalar_mapping_parse.test_interleaved_comment_between_keys", + "eval.tests.test_scalar_mapping_parse.test_leading_blank_lines_skipped", + "eval.tests.test_scalar_mapping_parse.test_negative_number_is_sequence_value", + "eval.tests.test_scalar_mapping_parse.test_no_space_after_colon_is_root_scalar[key3:val1\\n-key3]", + "eval.tests.test_scalar_mapping_parse.test_no_space_after_colon_is_root_scalar[key4 :val1\\n-key4]", + "eval.tests.test_scalar_mapping_parse.test_non_ascii_scalar_value", + "eval.tests.test_scalar_mapping_parse.test_quoted_scalar_preserves_quotes", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: -5\\n-a-yaml: a: type mismatch: \"a\" is yaml.List, want yaml.Scalar (at \"$\")]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: -5\\n-a[0]-5]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: -x\\n-a[0]-x]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: 1\\n-a-1]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: 3.14\\n-a-3.14]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: false\\n-a-false]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: hello world\\n-a-hello world]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: null\\n-a-null]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a: true\\n-a-true]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[a:\\n b: c\\n-a-yaml: a: type mismatch: \"a\" is yaml.Map, want yaml.Scalar (at \"$\")]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[empty: ''\\n-empty-'']", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[empty: \\n-empty-yaml: empty: \"empty\" not found]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[key1: val1\\n-key1-val1]", + "eval.tests.test_scalar_mapping_parse.test_scalar_mapping_parse[key2 : val1\\n-key2-val1]", + "eval.tests.test_scalar_mapping_parse.test_scalar_value_with_specials_preserved", + "eval.tests.test_selector_mismatches.test_absent_root_key_not_found", + "eval.tests.test_selector_mismatches.test_deep_list_chain_on_top_list", + "eval.tests.test_selector_mismatches.test_list_length_boundary", + "eval.tests.test_selector_mismatches.test_list_selector_on_map_value", + "eval.tests.test_selector_mismatches.test_map_selector_on_list_value", + "eval.tests.test_selector_mismatches.test_missing_intermediary_is_type_mismatch", + "eval.tests.test_selector_mismatches.test_mixed_chained_selectors_into_list_of_maps", + "eval.tests.test_selector_mismatches.test_scalar_selector_start", + "eval.tests.test_sequence_parse.test_indented_list_inside_map", + "eval.tests.test_sequence_parse.test_list_index_selector_on_scalar_type", + "eval.tests.test_sequence_parse.test_list_item_itself_is_map_type_mismatch", + "eval.tests.test_sequence_parse.test_list_negative_index_is_out_of_range", + "eval.tests.test_sequence_parse.test_list_non_numeric_index", + "eval.tests.test_sequence_parse.test_list_of_lists", + "eval.tests.test_sequence_parse.test_list_of_maps", + "eval.tests.test_sequence_parse.test_list_out_of_range_index", + "eval.tests.test_sequence_parse.test_top_level_list_scalars", + "eval.tests.test_sequence_parse.test_unsorted_list_order_preserved" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_types.test_default_config_yaml_missing_nonzero", + "eval.tests.test_types.test_default_file_flag_is_config_yaml", + "eval.tests.test_types.test_directory_as_file_rejected", + "eval.tests.test_types.test_empty_file_lookup", + "eval.tests.test_types.test_empty_mapping_value_not_found", + "eval.tests.test_types.test_empty_value_scalar_lookup", + "eval.tests.test_types.test_flat_list_whole_list_mismatch", + "eval.tests.test_types.test_float_index_splits_at_dot", + "eval.tests.test_types.test_help_flag_exit_code_and_stdout_stable_prefix", + "eval.tests.test_types.test_help_flag_prints_usage", + "eval.tests.test_types.test_index_out_of_bounds", + "eval.tests.test_types.test_index_out_of_bounds_list_of_maps", + "eval.tests.test_types.test_list_index_scalar[lists.yaml-params0-expected0]", + "eval.tests.test_types.test_list_index_scalar[lists.yaml-params1-expected1]", + "eval.tests.test_types.test_list_index_scalar[lists.yaml-params2-expected2]", + "eval.tests.test_types.test_list_index_scalar[simple.yaml-params3-expected3]", + "eval.tests.test_types.test_list_index_scalar[simple.yaml-params4-expected4]", + "eval.tests.test_types.test_list_of_lists_indexing", + "eval.tests.test_types.test_list_of_lists_other_branch", + "eval.tests.test_types.test_list_of_maps_first_element_name", + "eval.tests.test_types.test_list_of_maps_first_record_both_fields", + "eval.tests.test_types.test_list_of_maps_index_key", + "eval.tests.test_types.test_list_of_maps_second_record_both_fields", + "eval.tests.test_types.test_list_of_maps_whole_map_mismatch", + "eval.tests.test_types.test_list_of_scalars_mixed_fixture", + "eval.tests.test_types.test_list_whole_list_is_scalar_mismatch", + "eval.tests.test_types.test_map_leaf_after_list_of_maps", + "eval.tests.test_types.test_map_nested_via_list_index_then_key", + "eval.tests.test_types.test_map_whole_map_is_scalar_mismatch", + "eval.tests.test_types.test_map_whole_map_nested_mismatch", + "eval.tests.test_types.test_middle_list_index", + "eval.tests.test_types.test_missing_file_absolute_path_diagnostic", + "eval.tests.test_types.test_missing_file_exits_nonzero_stderr", + "eval.tests.test_types.test_missing_key_in_list_of_maps", + "eval.tests.test_types.test_missing_nested_key", + "eval.tests.test_types.test_missing_top_level_key", + "eval.tests.test_types.test_multiple_params_bracket_and_error", + "eval.tests.test_types.test_multiple_params_width_and_errors", + "eval.tests.test_types.test_negative_index", + "eval.tests.test_types.test_no_params_prints_nothing", + "eval.tests.test_types.test_non_integer_index", + "eval.tests.test_types.test_plus_signed_index_resolves", + "eval.tests.test_types.test_relative_file_path", + "eval.tests.test_types.test_repeated_param_lookup", + "eval.tests.test_types.test_scalar_bool_passthrough_is_string", + "eval.tests.test_types.test_scalar_folded_newline_value", + "eval.tests.test_types.test_scalar_integer_like_quoted", + "eval.tests.test_types.test_scalar_lookup[narrow.yaml-params5-expected5]", + "eval.tests.test_types.test_scalar_lookup[narrow.yaml-params6-expected6]", + "eval.tests.test_types.test_scalar_lookup[narrow.yaml-params7-expected7]", + "eval.tests.test_types.test_scalar_lookup[simple.yaml-params0-expected0]", + "eval.tests.test_types.test_scalar_lookup[simple.yaml-params1-expected1]", + "eval.tests.test_types.test_scalar_lookup[simple.yaml-params2-expected2]", + "eval.tests.test_types.test_scalar_lookup[simple.yaml-params3-expected3]", + "eval.tests.test_types.test_scalar_lookup[simple.yaml-params4-expected4]", + "eval.tests.test_types.test_scalar_multiword_value", + "eval.tests.test_types.test_scalar_quote_escaping", + "eval.tests.test_types.test_scalar_single_key_dotted_then_unprefixed", + "eval.tests.test_types.test_scalar_tab_quoting", + "eval.tests.test_types.test_scalar_unicode_passthrough", + "eval.tests.test_types.test_scalar_with_bracket_char", + "eval.tests.test_types.test_single_dash_help_flag", + "eval.tests.test_types.test_two_scalars_equal_width", + "eval.tests.test_types.test_wide_param_dominates_alignment", + "eval.tests.test_types.test_zero_index_resolves_first", + "eval.tests.test_types_extended.test_bare_dot_unsets_kwarg", + "eval.tests.test_types_extended.test_deep_mixed_chain_scalar", + "eval.tests.test_types_extended.test_empty_param_root_list_type_mismatch", + "eval.tests.test_types_extended.test_empty_param_root_map_type_mismatch", + "eval.tests.test_types_extended.test_empty_param_root_scalar", + "eval.tests.test_types_extended.test_index_on_root_map_reports_want_list", + "eval.tests.test_types_extended.test_index_on_scalar_reports_want_list", + "eval.tests.test_types_extended.test_intermediate_map_expected_list_mismatch", + "eval.tests.test_types_extended.test_map_key_case_miss_reports_not_found", + "eval.tests.test_types_extended.test_map_key_hyphen", + "eval.tests.test_types_extended.test_map_key_underscore", + "eval.tests.test_types_extended.test_map_keys_are_case_sensitive", + "eval.tests.test_types_extended.test_map_mixed_case_key", + "eval.tests.test_types_extended.test_missing_tail_after_deep_groups", + "eval.tests.test_types_extended.test_multi_param_root_index_error_batch", + "eval.tests.test_types_extended.test_multi_param_scalar_width_alignment", + "eval.tests.test_types_extended.test_root_list_index_out_of_bounds", + "eval.tests.test_types_extended.test_root_list_index_resolves", + "eval.tests.test_types_extended.test_root_list_index_then_key_not_found", + "eval.tests.test_types_extended.test_scalar_backslash_token_value", + "eval.tests.test_types_extended.test_scalar_dotted_ip_value", + "eval.tests.test_types_extended.test_scalar_float_value", + "eval.tests.test_types_extended.test_scalar_folded_multiline_order", + "eval.tests.test_types_extended.test_scalar_hexlike_value", + "eval.tests.test_types_extended.test_scalar_leading_zero_value", + "eval.tests.test_types_extended.test_scalar_literal_empty_quotes_value", + "eval.tests.test_types_extended.test_scalar_plain_zero_value", + "eval.tests.test_types_parser_edges.test_block_scalar_list_item_folded_with_marker", + "eval.tests.test_types_parser_edges.test_block_scalar_with_inline_comment_keeps_tail", + "eval.tests.test_types_parser_edges.test_list_mixing_scalar_and_map_items", + "eval.tests.test_types_parser_edges.test_map_with_list_value_width_alignment", + "eval.tests.test_types_parser_edges.test_nested_map_where_list_expected_panics", + "eval.tests.test_types_parser_edges.test_nil_child_value_in_list_of_maps", + "eval.tests.test_types_parser_edges.test_out_of_range_indexes_in_list_of_scalars", + "eval.tests.test_types_parser_edges.test_quoted_colon_key_is_scalar_root", + "eval.tests.test_types_parser_edges.test_root_block_scalar_resolves", + "eval.tests.test_types_parser_edges.test_root_list_then_map_key_panics", + "eval.tests.test_types_parser_edges.test_root_numeric_scalar_then_map_panics", + "eval.tests.test_types_parser_edges.test_root_scalar_then_list_panics", + "eval.tests.test_types_parser_edges.test_scalar_trailing_spaces_preserved", + "eval.tests.test_types_parser_edges.test_scalar_value_starting_with_dot_preserved", + "eval.tests.test_types_parser_edges.test_sequence_of_sequences_within_map", + "eval.tests.test_types_parser_edges.test_spaces_before_mapping_colon_key", + "eval.tests.test_types_scalar_edges.test_backslash_u_text_kept_literal", + "eval.tests.test_types_scalar_edges.test_blank_and_comment_lines_between_keys", + "eval.tests.test_types_scalar_edges.test_block_scalar_empty", + "eval.tests.test_types_scalar_edges.test_block_scalar_numeric_content_is_scalar", + "eval.tests.test_types_scalar_edges.test_block_scalar_single_line", + "eval.tests.test_types_scalar_edges.test_block_scalar_terminates_at_blank_line", + "eval.tests.test_types_scalar_edges.test_block_scalar_two_lines", + "eval.tests.test_types_scalar_edges.test_capitalized_null_tokens_kept", + "eval.tests.test_types_scalar_edges.test_colon_inside_scalar_value", + "eval.tests.test_types_scalar_edges.test_comma_list_token_is_scalar", + "eval.tests.test_types_scalar_edges.test_deep_nested_list_in_map_chain", + "eval.tests.test_types_scalar_edges.test_dot_key_on_scalar_reports_want_map", + "eval.tests.test_types_scalar_edges.test_double_quoted_value_keeps_quotes", + "eval.tests.test_types_scalar_edges.test_duplicate_key_last_wins", + "eval.tests.test_types_scalar_edges.test_empty_brace_token_is_scalar", + "eval.tests.test_types_scalar_edges.test_empty_bracket_token_is_scalar", + "eval.tests.test_types_scalar_edges.test_index_leading_zeros_resolves_first", + "eval.tests.test_types_scalar_edges.test_index_on_scalar_reports_want_list_midchain", + "eval.tests.test_types_scalar_edges.test_index_plus_sign_with_leading_zero", + "eval.tests.test_types_scalar_edges.test_index_then_dot_on_scalar_element", + "eval.tests.test_types_scalar_edges.test_index_with_space_is_not_found", + "eval.tests.test_types_scalar_edges.test_inline_hash_kept_in_value", + "eval.tests.test_types_scalar_edges.test_inline_hash_kept_in_word_value", + "eval.tests.test_types_scalar_edges.test_leading_spaces_after_colon_trimmed", + "eval.tests.test_types_scalar_edges.test_list_in_list_indexing", + "eval.tests.test_types_scalar_edges.test_multi_colon_scalar_value", + "eval.tests.test_types_scalar_edges.test_multi_line_double_quoted_scalar_parser_error", + "eval.tests.test_types_scalar_edges.test_no_space_colon_makes_root_scalar", + "eval.tests.test_types_scalar_edges.test_null_word_token_is_scalar_string", + "eval.tests.test_types_scalar_edges.test_numeric_root_scalar_empty_param", + "eval.tests.test_types_scalar_edges.test_real_tab_byte_quoted", + "eval.tests.test_types_scalar_edges.test_root_scalar_document_empty_param", + "eval.tests.test_types_scalar_edges.test_root_sequence_element_then_dot", + "eval.tests.test_types_scalar_edges.test_tab_key_separator_makes_root_scalar", + "eval.tests.test_types_scalar_edges.test_tilde_token_is_scalar_string" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_block_scalar_surface.test_block_scalar_alignment_across_params", + "eval.tests.test_block_scalar_surface.test_block_scalar_cannot_be_indexed", + "eval.tests.test_block_scalar_surface.test_block_scalar_is_single_scalar_value", + "eval.tests.test_block_scalar_surface.test_block_scalar_value_rendering_matches_golden[folded-folded_scalar.golden]", + "eval.tests.test_block_scalar_surface.test_block_scalar_value_rendering_matches_golden[multi-block_scalar_literal.golden]", + "eval.tests.test_block_scalar_surface.test_block_scalar_value_rendering_matches_golden[s1-block_scalar_strip.golden]", + "eval.tests.test_block_scalar_surface.test_block_scalar_value_rendering_matches_golden[s2-block_scalar_keep.golden]", + "eval.tests.test_block_scalar_surface.test_block_scalar_value_rendering_matches_golden[s3-block_scalar_escapes.golden]", + "eval.tests.test_child_edges.test_deep_index_followed_by_map", + "eval.tests.test_child_edges.test_dot_only_spec", + "eval.tests.test_child_edges.test_empty_scalar_value_key", + "eval.tests.test_child_edges.test_empty_spec_reaches_root", + "eval.tests.test_child_edges.test_leading_dot_index_combo", + "eval.tests.test_child_edges.test_non_numeric_index_not_found[top.list[ 0]-yaml: .top.list[ 0]: \".top.list[ 0]\" not found]", + "eval.tests.test_child_edges.test_non_numeric_index_not_found[top.list[0x]-yaml: .top.list[0x]: \".top.list[0x]\" not found]", + "eval.tests.test_child_edges.test_non_numeric_index_not_found[top.list[]-yaml: .top.list[]: \".top.list[]\" not found]", + "eval.tests.test_child_edges.test_non_numeric_index_not_found[top.list[abc]-yaml: .top.list[abc]: \".top.list[abc]\" not found]", + "eval.tests.test_child_edges.test_trailing_dot_spec", + "eval.tests.test_child_traversal.test_explicit_leading_dot[.matrix[1][0]-c]", + "eval.tests.test_child_traversal.test_explicit_leading_dot[.top.list[0]-one]", + "eval.tests.test_child_traversal.test_explicit_leading_dot[.top.mid.bottom.scalar-hello]", + "eval.tests.test_child_traversal.test_implied_dot_for_bare_key", + "eval.tests.test_child_traversal.test_list_of_lists_recursive_index", + "eval.tests.test_child_traversal.test_nested_map_of_maps", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-matrix[0][0]-a]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-matrix[0][1]-b]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-matrix[1][0]-c]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-matrix[1][1]-d]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.list[0]-one]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.list[1]-two]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.list[2].nested.inner-deepvalue]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.mid.bottom.boolean-true]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.mid.bottom.num-42]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/deep.yaml-top.mid.bottom.scalar-hello]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-config.server[0]-www.google.com]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-config.server[1]-www.cnn.com]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-config.server[2]-www.example.com]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-dict.a-1]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-dict.b.c-2]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-dict.b.d[0]-x]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-dict.b.d[1]-y]", + "eval.tests.test_child_traversal.test_traversal_reaches_scalar[/workspace/eval/test_resources/mixed.yaml-dict.e.f-g]", + "eval.tests.test_cli.test_causal_chain_build_then_read", + "eval.tests.test_cli.test_default_file_flag_documented_in_help", + "eval.tests.test_cli.test_empty_config_lookup_after_write", + "eval.tests.test_cli.test_file_flag_overrides_default", + "eval.tests.test_cli.test_help_long_flag", + "eval.tests.test_cli.test_invalid_flag_errors_nonzero", + "eval.tests.test_cli.test_mixed_success_and_error_params_one_run", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_duplicate_key_type_change_to_list", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_duplicate_map_key_last_wins[k-second]", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_empty_list_member_is_nil_not_found", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_nil_value_key_not_found[blank-yaml: blank: \"blank\" not found]", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_nil_value_key_not_found[nilval-yaml: nilval: \"nilval\" not found]", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_nil_value_partial_trace", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_quoted_empty_string_is_valid_scalar", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_scalar_root_emptyspec_resolves", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_scalar_root_mapkey_spec_type_mismatch", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_zero_and_quoted_zero_scalars[num0-\"0\"]", + "eval.tests.test_dup_keys_nil_vs_empty_scalar.test_zero_and_quoted_zero_scalars[zero_str-\"\\\\\"0\\\\\"\"]", + "eval.tests.test_errors.test_dot_selector_on_list_type_mismatch", + "eval.tests.test_errors.test_extend_scalar_then_selector_type_mismatch", + "eval.tests.test_errors.test_get_on_container_type_mismatch[/workspace/eval/test_resources/basic.yaml-list-yaml: list: type mismatch: \"list\" is yaml.List, want yaml.Scalar (at \"$\")]", + "eval.tests.test_errors.test_get_on_container_type_mismatch[/workspace/eval/test_resources/deep.yaml-top-yaml: top: type mismatch: \"top\" is yaml.Map, want yaml.Scalar (at \"$\")]", + "eval.tests.test_errors.test_get_on_container_type_mismatch[/workspace/eval/test_resources/mixed.yaml-config-yaml: config: type mismatch: \"config\" is yaml.Map, want yaml.Scalar (at \"$\")]", + "eval.tests.test_errors.test_get_on_container_type_mismatch[/workspace/eval/test_resources/mixed.yaml-dict-yaml: dict: type mismatch: \"dict\" is yaml.Map, want yaml.Scalar (at \"$\")]", + "eval.tests.test_errors.test_index_out_of_range_not_found[top.list[-1]-yaml: .top.list[-1]: \".top.list[-1]\" not found]", + "eval.tests.test_errors.test_index_out_of_range_not_found[top.list[10]-yaml: .top.list[10]: \".top.list[10]\" not found]", + "eval.tests.test_errors.test_index_out_of_range_not_found[top.list[5]-yaml: .top.list[5]: \".top.list[5]\" not found]", + "eval.tests.test_errors.test_index_out_of_range_not_found[top.list[999]-yaml: .top.list[999]: \".top.list[999]\" not found]", + "eval.tests.test_errors.test_index_selector_on_non_list[matrix[0]-yaml: matrix[0]: type mismatch: \"matrix[0]\" is yaml.List, want yaml.Scalar (at \"$\")]", + "eval.tests.test_errors.test_index_selector_on_non_list[top.mid[0]-yaml: .top.mid[0]: type mismatch: \".top.mid\" is yaml.Map, want yaml.List (at \"[0]\")]", + "eval.tests.test_errors.test_index_selector_on_non_list[top[0]-yaml: .top[0]: type mismatch: \".top\" is yaml.Map, want yaml.List (at \"[0]\")]", + "eval.tests.test_errors.test_index_selector_on_scalar", + "eval.tests.test_errors.test_key_followed_by_missing_map_val_type_mismatch", + "eval.tests.test_errors.test_lookup_of_sequence_typed_value_neg_number", + "eval.tests.test_errors.test_missing_intermediate_node_reports_partial_spec", + "eval.tests.test_errors.test_missing_key_not_found[/workspace/eval/test_resources/basic.yaml-mapping.nope-yaml: .mapping.nope: \".mapping.nope\" not found]", + "eval.tests.test_errors.test_missing_key_not_found[/workspace/eval/test_resources/basic.yaml-nonexistent-yaml: .nonexistent: \".nonexistent\" not found]", + "eval.tests.test_errors.test_missing_key_not_found[/workspace/eval/test_resources/deep.yaml-top.mid.bottom.nope-yaml: .top.mid.bottom.nope: \".top.mid.bottom.nope\" not found]", + "eval.tests.test_errors.test_missing_key_not_found[/workspace/eval/test_resources/deep.yaml-top.mid.nope-yaml: .top.mid.nope: \".top.mid.nope\" not found]", + "eval.tests.test_flow_syntax_and_inline_comments.test_flow_style_value_is_scalar[emptylist-[]]", + "eval.tests.test_flow_syntax_and_inline_comments.test_flow_style_value_is_scalar[emptymap-{}]", + "eval.tests.test_flow_syntax_and_inline_comments.test_flow_style_value_is_scalar[flowlist-[a, b, c]]", + "eval.tests.test_flow_syntax_and_inline_comments.test_index_selector_on_flow_scalar_mismatch[emptylist[0]-\".emptylist\" is yaml.Scalar, want yaml.List (at \"[0]\")]", + "eval.tests.test_flow_syntax_and_inline_comments.test_index_selector_on_flow_scalar_mismatch[flowlist[1]-\".flowlist\" is yaml.Scalar, want yaml.List (at \"[1]\")]", + "eval.tests.test_flow_syntax_and_inline_comments.test_inline_comment_compact_number_alignment", + "eval.tests.test_flow_syntax_and_inline_comments.test_inline_comment_retained_in_value[a2-val # trailing]", + "eval.tests.test_flow_syntax_and_inline_comments.test_inline_comment_retained_in_value[inl_comment-1 # trailing comment]", + "eval.tests.test_flow_syntax_and_inline_comments.test_map_selector_on_flow_scalar_mismatch[emptymap.x-\".emptymap\" is yaml.Scalar, want yaml.Map (at \".x\")]", + "eval.tests.test_get_scalar.test_multiple_params_align_width", + "eval.tests.test_get_scalar.test_order_preserved_across_params", + "eval.tests.test_get_scalar.test_scalar_lookup_single[/workspace/eval/test_resources/basic.yaml-list[0]-item1]", + "eval.tests.test_get_scalar.test_scalar_lookup_single[/workspace/eval/test_resources/basic.yaml-list[1]-item2]", + "eval.tests.test_get_scalar.test_scalar_lookup_single[/workspace/eval/test_resources/basic.yaml-mapping.key1-value1]", + "eval.tests.test_get_scalar.test_scalar_lookup_single[/workspace/eval/test_resources/basic.yaml-mapping.key2-value2]", + "eval.tests.test_get_scalar.test_scalar_value_variants[boolfalse-\"false\"]", + "eval.tests.test_get_scalar.test_scalar_value_variants[booltrue-\"true\"]", + "eval.tests.test_get_scalar.test_scalar_value_variants[float-\"3.14\"]", + "eval.tests.test_get_scalar.test_scalar_value_variants[host-\"\\\\\"localhost:8080\\\\\"\"]", + "eval.tests.test_get_scalar.test_scalar_value_variants[num-\"42\"]", + "eval.tests.test_get_scalar.test_scalar_value_variants[quoted-\"\\\\\"hello world\\\\\"\"]", + "eval.tests.test_get_scalar.test_single_param_no_padding", + "eval.tests.test_get_scalar.test_widest_param_drives_alignment", + "eval.tests.test_index_token_parsing.test_index_token_int_overflow_not_found", + "eval.tests.test_index_token_parsing.test_index_token_with_internal_space_not_found[[ 1]-yaml: [ 1]: \"[ 1]\" not found]", + "eval.tests.test_index_token_parsing.test_index_token_with_internal_space_not_found[[1 ]-yaml: [1 ]: \"[1 ]\" not found]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_in_double_index[matrix[+0][1]-b]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_in_double_index[matrix[01][0]-c]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_in_double_index[matrix[0][+1]-b]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_index_on_nested_list[list[+0]-item1]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_index_on_nested_list[list[001]-item2]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_index_on_nested_list[list[01]-item2]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_on_url_list[/workspace/eval/test_resources/mixed.yaml-config.server[+1]-www.cnn.com]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_on_url_list[/workspace/eval/test_resources/mixed.yaml-config.server[01]-www.cnn.com]", + "eval.tests.test_index_token_parsing.test_leading_plus_and_zero_on_url_list[/workspace/eval/test_resources/mixed.yaml-config.server[0]-www.google.com]", + "eval.tests.test_index_token_parsing.test_leading_plus_index_selects_element[[+0]-alpha]", + "eval.tests.test_index_token_parsing.test_leading_plus_index_selects_element[[+1]-beta]", + "eval.tests.test_index_token_parsing.test_leading_plus_index_selects_element[[+2]-gamma]", + "eval.tests.test_index_token_parsing.test_leading_zero_index_is_decimal[[001]-beta]", + "eval.tests.test_index_token_parsing.test_leading_zero_index_is_decimal[[01]-beta]", + "eval.tests.test_index_token_parsing.test_negative_zero_index_is_zero", + "eval.tests.test_index_token_parsing.test_single_element_list_second_index_not_found", + "eval.tests.test_plain_long_scalar_concatenation.test_long_scalar_alignment_with_short_sibling", + "eval.tests.test_plain_long_scalar_concatenation.test_long_scalar_first_line_words_kept_whole", + "eval.tests.test_plain_long_scalar_concatenation.test_plain_long_scalar_reverse_concat[/workspace/eval/test_resources/long_blank_line.yaml-key = \"ipsum lorem\"\\n]", + "eval.tests.test_plain_long_scalar_concatenation.test_plain_long_scalar_reverse_concat[/workspace/eval/test_resources/long_scalar.yaml-key = \"amet dolor sit lorem ipsum\"\\n]", + "eval.tests.test_plain_long_scalar_concatenation.test_plain_long_scalar_reverse_concat[/workspace/eval/test_resources/long_single.yaml-key = \"single\"\\n]", + "eval.tests.test_plain_long_scalar_concatenation.test_plain_long_scalar_reverse_concat[/workspace/eval/test_resources/long_varying_indent.yaml-key = \"back deeper first line\"\\n]", + "eval.tests.test_reachability_breadth.test_append_map_selector_to_neg_list_scalar", + "eval.tests.test_reachability_breadth.test_error_after_valid_index_partial_trace[config.admin[0].user-yaml: .config.admin[0].user: \".config.admin[0].user\" not found]", + "eval.tests.test_reachability_breadth.test_error_after_valid_index_partial_trace[config.admin[5].password-yaml: .config.admin[5].password: \".config.admin[5]\" not found]", + "eval.tests.test_reachability_breadth.test_multiscalar_fixture_breadth[nested.a.b.c.deep-found-it]", + "eval.tests.test_reachability_breadth.test_multiscalar_fixture_breadth[scalars.first-value1]", + "eval.tests.test_reachability_breadth.test_multiscalar_fixture_breadth[scalars.fourth-value4]", + "eval.tests.test_reachability_breadth.test_multiscalar_fixture_breadth[scalars.second-value2]", + "eval.tests.test_reachability_breadth.test_multiscalar_fixture_breadth[scalars.third-value3]", + "eval.tests.test_reachability_breadth.test_valid_index_then_present_member", + "eval.tests.test_readfile.test_parsing_spec_format_variants_loaded_from_file", + "eval.tests.test_readfile.test_readfile_absolute_and_relative_path", + "eval.tests.test_readfile.test_readfile_comments_only_file_no_hits", + "eval.tests.test_readfile.test_readfile_directory_errors", + "eval.tests.test_readfile.test_readfile_empty_file_no_hits", + "eval.tests.test_readfile.test_readfile_error_report_mentions_finished_readfile", + "eval.tests.test_readfile.test_readfile_missing_file_errors_nonzero", + "eval.tests.test_readfile.test_readfile_nested_array_loaded", + "eval.tests.test_readfile.test_readfile_valid_basic_file", + "eval.tests.test_root_list_and_spec_edges.test_deep_spec_missing_top_level_key", + "eval.tests.test_root_list_and_spec_edges.test_inner_index_out_of_range[matrix[0][2]-yaml: .matrix[0][2]: \".matrix[0][2]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_inner_index_out_of_range[matrix[2]-yaml: .matrix[2]: \".matrix[2]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_odd_spec_token_not_found[..-yaml: ..: \".\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_odd_spec_token_not_found[.[-yaml: .[: \".\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_odd_spec_token_not_found[]-yaml: .]: \".]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_odd_spec_token_not_found[top.list[0]]-yaml: .top.list[0]]: \".top.list[0]]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_odd_spec_token_not_found[top]-yaml: .top]: \".top]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_bare_key_selector_type_mismatch[0-yaml: .0: type mismatch: \"\" is yaml.List, want yaml.Map (at \".0\")]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_bare_key_selector_type_mismatch[alpha-yaml: .alpha: type mismatch: \"\" is yaml.List, want yaml.Map (at \".alpha\")]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_empty_spec_type_mismatch", + "eval.tests.test_root_list_and_spec_edges.test_root_list_index_not_found[[-1]-yaml: [-1]: \"[-1]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_index_not_found[[3]-yaml: [3]: \"[3]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_index_not_found[[999]-yaml: [999]: \"[999]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_index_not_found[[abc]-yaml: [abc]: \"[abc]\" not found]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_positive_index[[0]-alpha]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_positive_index[[1]-beta]", + "eval.tests.test_root_list_and_spec_edges.test_root_list_positive_index[[2]-gamma]", + "eval.tests.test_root_list_and_spec_edges.test_unterminated_index_selector_type_mismatch[[-yaml: [: type mismatch: \"\" is yaml.Map, want yaml.List (at \"[\")]", + "eval.tests.test_root_list_and_spec_edges.test_unterminated_index_selector_type_mismatch[top.mid.bottom.scalar[-yaml: .top.mid.bottom.scalar[: type mismatch: \".top.mid.bottom.scalar\" is yaml.Scalar, want yaml.List (at \"[\")]", + "eval.tests.test_root_list_and_spec_edges.test_unterminated_index_selector_type_mismatch[top[-yaml: .top[: type mismatch: \".top\" is yaml.Map, want yaml.List (at \"[\")]", + "eval.tests.test_root_scalar_concat_and_empty_key.test_empty_key_map_edges[- = yaml: : type mismatch: \"\" is yaml.Map, want yaml.Scalar (at \"$\")\\n]", + "eval.tests.test_root_scalar_concat_and_empty_key.test_empty_key_map_edges[.-. = \"value\"\\n]", + "eval.tests.test_root_scalar_concat_and_empty_key.test_empty_key_map_siblings_alignment", + "eval.tests.test_root_scalar_concat_and_empty_key.test_empty_spec_on_multiline_scalar_root", + "eval.tests.test_root_scalar_concat_and_empty_key.test_nil_root_empty_spec_not_found", + "eval.tests.test_root_scalar_concat_and_empty_key.test_root_multiline_scalar_concat[/workspace/eval/test_resources/root_scalar_2.yaml- = \"world hello\"\\n]", + "eval.tests.test_root_scalar_concat_and_empty_key.test_root_multiline_scalar_concat[/workspace/eval/test_resources/root_scalar_3.yaml- = \"cc bb aa\"\\n]", + "eval.tests.test_root_scalar_concat_and_empty_key.test_scalar_root_index_and_map_spec_alignment", + "eval.tests.test_root_scalar_concat_and_empty_key.test_scalar_root_index_selector_mismatch", + "eval.tests.test_scalar_escape_formatting.test_escape_and_numeric_scalar_display[n-\"12345\"]", + "eval.tests.test_scalar_escape_formatting.test_escape_and_numeric_scalar_display[q-\"\\\\\"a\\\\\\\\\\\\\"b\\\\\\\\\\\\\\\\c\\\\\"\"]", + "eval.tests.test_scalar_escape_formatting.test_escape_and_numeric_scalar_display[s-\"\\\\\"line1\\\\\\\\nline2\\\\\"\"]", + "eval.tests.test_scalar_escape_formatting.test_escape_and_numeric_scalar_display[tabval-\"\\\\\"a\\\\tb\\\\\"\"]", + "eval.tests.test_scalar_escape_formatting.test_escape_and_numeric_scalar_display[u-\"\\\\\"a:b:c\\\\\"\"]", + "eval.tests.test_scalar_escape_formatting.test_escape_scalars_alignment_across_params", + "eval.tests.test_short_mapping_and_quoted_continuation.test_quoted_prefix_continues_to_end_of_line", + "eval.tests.test_short_mapping_and_quoted_continuation.test_quoted_prefix_with_tab_after_quote", + "eval.tests.test_short_mapping_and_quoted_continuation.test_short_mapping_collapse_alignment", + "eval.tests.test_short_mapping_and_quoted_continuation.test_short_mapping_first_key_is_map", + "eval.tests.test_short_mapping_and_quoted_continuation.test_short_mapping_first_key_value_is_nil", + "eval.tests.test_short_mapping_and_quoted_continuation.test_short_mapping_later_word_not_top_level" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_yget_loading_help.TestHelpAndUsage.test_help_does_not_need_config", + "eval.tests.test_yget_loading_help.TestHelpAndUsage.test_help_variants[--help]", + "eval.tests.test_yget_loading_help.TestHelpAndUsage.test_help_variants[-h]", + "eval.tests.test_yget_loading_help.TestHelpAndUsage.test_help_variants[-help]", + "eval.tests.test_yget_loading_help.TestHelpAndUsage.test_usage_docs_param_syntax", + "eval.tests.test_yget_loading_help.TestReadFileErrors.test_default_config_missing", + "eval.tests.test_yget_loading_help.TestReadFileErrors.test_empty_file_flag", + "eval.tests.test_yget_loading_help.TestReadFileErrors.test_file_is_directory", + "eval.tests.test_yget_loading_help.TestReadFileErrors.test_no_params_still_reads_file", + "eval.tests.test_yget_loading_help.TestReadFileErrors.test_nonexistent_flagged_file", + "eval.tests.test_yget_loading_help.test_malformed_yaml_read_errors[a: b\\n c:\\n - x\\n - bad\\n-interface conversion]", + "eval.tests.test_yget_loading_help.test_malformed_yaml_read_errors[top:\\n - a\\n - b: c\\n d\\n e\\n-cannot append scalar to non-scalar node]", + "eval.tests.test_yget_lookup_errors.TestMixedSuccessAndErrors.test_all_errors_no_values", + "eval.tests.test_yget_lookup_errors.TestMixedSuccessAndErrors.test_mixed_line_alignment", + "eval.tests.test_yget_lookup_errors.TestMixedSuccessAndErrors.test_whitespace_trimmed_param_path", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_into_missing_intermediate", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[-1]-\".config.server[-1]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[-5]-\".config.server[-5]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[3]-\".config.server[3]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[999999]-\".config.server[999999]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[9]-\".config.server[9]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[]-\".config.server[]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_index_out_of_range[config.server[abc]-\".config.server[abc]\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_missing_key[mapping.nope-\".mapping.nope\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeNotFound.test_missing_key[nope-\".nope\" not found]", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_array_into_mapping", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_deep_path_under_existing_scalar", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_lookup_into_scalar_as_map", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_negative_scalar_parses_as_list", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_node_not_scalar[list-yaml.List-yaml.Scalar-\"$\"]", + "eval.tests.test_yget_lookup_errors.TestNodeTypeMismatch.test_node_not_scalar[mapping-yaml.Map-yaml.Scalar-\"$\"]", + "eval.tests.test_yget_process_io.TestOutputChannels.test_empty_args_success", + "eval.tests.test_yget_process_io.TestOutputChannels.test_file_error_on_stderr_exit1", + "eval.tests.test_yget_process_io.TestOutputChannels.test_lookup_error_on_stdout", + "eval.tests.test_yget_process_io.TestOutputChannels.test_lookup_value_on_stdout", + "eval.tests.test_yget_process_io.TestOutputChannels.test_many_params", + "eval.tests.test_yget_process_io.TestPositiveIndexFormats.test_index_format_variants[[+1]-\"b\"]", + "eval.tests.test_yget_process_io.TestPositiveIndexFormats.test_index_format_variants[[01]-\"b\"]", + "eval.tests.test_yget_process_io.TestWidthColumn.test_equal_length_params", + "eval.tests.test_yget_process_io.TestWidthColumn.test_one_wide_param_pads_others", + "eval.tests.test_yget_process_io.TestWidthColumn.test_single_param_owns_width", + "eval.tests.test_yget_process_io.test_flag_value_with_equals_separator", + "eval.tests.test_yget_root_node_kind.TestEmptyStringParam.test_empty_param_aligns_in_column", + "eval.tests.test_yget_root_node_kind.TestEmptyStringParam.test_empty_param_on_empty_document", + "eval.tests.test_yget_root_node_kind.TestEmptyStringParam.test_empty_param_on_list_root", + "eval.tests.test_yget_root_node_kind.TestEmptyStringParam.test_empty_param_on_mapping_root", + "eval.tests.test_yget_root_node_kind.test_empty_and_comment_document[# just a comment\\n-a = yaml: .a: \"\" not found\\n]", + "eval.tests.test_yget_root_node_kind.test_empty_and_comment_document[-a = yaml: .a: \"\" not found\\n]", + "eval.tests.test_yget_root_node_kind.test_root_scalar_document", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[a: true\\nb: false\\ny: yes\\nn: no\\nz: null\\nt: ~\\n-params3-a = \"true\"\\nb = \"false\"\\ny = \"yes\"\\nn = \"no\"\\nz = \"null\"\\nt = \"~\"\\n]", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[i: 12345\\nf: 3.14159\\n-params4-i = \"12345\"\\nf = \"3.14159\"\\n]", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[k: 'a b'\\n-params2-k = \"'a b'\"\\n]", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[k: a:b\\n-params5-k = \"a:b\"\\n]", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[k: |\\n alpha\\n beta\\n-params1-k = \"\\\\nalpha\\\\nbeta\"\\n]", + "eval.tests.test_yget_scalar_format.test_scalar_value_rendering[k: |\\n line1\\n line2\\n-params0-k = \"\\\\nline1\\\\nline2\"\\n]", + "eval.tests.test_yget_scalar_format.test_value_with_double_quotes_kept", + "eval.tests.test_yget_scalar_success.test_argv_order_is_preserved", + "eval.tests.test_yget_scalar_success.test_column_alignment_by_longest_param", + "eval.tests.test_yget_scalar_success.test_dot_only_param_reports_not_found", + "eval.tests.test_yget_scalar_success.test_duplicate_param_prints_twice", + "eval.tests.test_yget_scalar_success.test_implicit_and_explicit_leading_dot", + "eval.tests.test_yget_scalar_success.test_multi_param_lookup[/workspace/eval/test_resources/advanced.yaml-params0-expected_lines0]", + "eval.tests.test_yget_scalar_success.test_multi_param_lookup[/workspace/eval/test_resources/advanced.yaml-params1-expected_lines1]", + "eval.tests.test_yget_scalar_success.test_multi_param_lookup[/workspace/eval/test_resources/advanced.yaml-params2-expected_lines2]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.admin[0].password-\"z3u5\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.admin[0].username-\"god\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.admin[1].password-\"f!r3m3\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.admin[1].username-\"lowly\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.server[0]-\"www.google.com\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.server[1]-\"www.cnn.com\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-config.server[2]-\"www.example.com\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-list[0]-\"item1\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-list[1]-\"item2\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-mapping.key1-\"value1\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/example.yaml-mapping.key2-\"value2\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-dollar_ref-\"$HOME\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-empty-\"\\\\\"\\\\\"\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-enabled-\"true\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-greeting-\"hello world\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-pi-\"3.14\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-port-\"8080\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-quoted_pairs-\"a/b\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-url-\"http://example.com/x[1]\"]", + "eval.tests.test_yget_scalar_success.test_single_scalar_lookup[/workspace/eval/test_resources/scalars.yaml-zero-\"0\"]", + "eval.tests.test_yget_sequence_depth.TestRootListDocument.test_root_list_as_scalar_type_mismatch", + "eval.tests.test_yget_sequence_depth.TestRootListDocument.test_root_list_index[[0]-[0] = \"a\"\\n]", + "eval.tests.test_yget_sequence_depth.TestRootListDocument.test_root_list_index[[1]-[1] = \"b\"\\n]", + "eval.tests.test_yget_sequence_depth.TestRootListDocument.test_root_list_index[[9]-[9] = yaml: [9]: \"[9]\" not found\\n]", + "eval.tests.test_yget_sequence_depth.test_list_of_lists_lookup[m[0][0]-m[0][0] = \"x\"\\n]", + "eval.tests.test_yget_sequence_depth.test_list_of_lists_lookup[m[0][1]-m[0][1] = \"y\"\\n]", + "eval.tests.test_yget_sequence_depth.test_list_of_lists_lookup[m[0][3]-m[0][3] = yaml: .m[0][3]: \".m[0][3]\" not found\\n]", + "eval.tests.test_yget_sequence_depth.test_list_of_lists_lookup[m[1][0]-m[1][0] = \"p\"\\n]", + "eval.tests.test_yget_sequence_depth.test_list_of_lists_lookup[m[2]-m[2] = yaml: .m[2]: \".m[2]\" not found\\n]", + "eval.tests.test_yget_sequence_depth.test_scalar_element_drilled_as_map", + "eval.tests.test_yget_sequence_depth.test_triple_nested_list", + "eval.tests.test_yget_width_bytes.test_width_by_byte_length[a: 1\\n\\xe9\\xe9: 2\\n-params0-a = \"1\"\\n\\xe9\\xe9 = \"2\"\\n]", + "eval.tests.test_yget_width_bytes.test_width_by_byte_length[a: 1\\n\\xe9\\xe9: 2\\n-params1-\\xe9\\xe9 = \"2\"\\na = \"1\"\\n]", + "eval.tests.test_yget_width_bytes.test_width_by_byte_length[a: 1\\n\\xe9\\xe9: 2\\n-params3- = yaml: : type mismatch: \"\" is yaml.Map, want yaml.Scalar (at \"$\")\\n\\xe9\\xe9 = \"2\"\\n]", + "eval.tests.test_yget_width_bytes.test_width_by_byte_length[x: 5\\nyy: 6\\nzzz: 3\\n-params2-x = \"5\"\\nyy = \"6\"\\nzzz = \"3\"\\n]" + ] + } + }, + "commit": "95000da7cfdd034f2a86bdd5e11df3372bae5c0d", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 0.9642596301968491, + "eval_clean_hashes": [ + "85dc91de670a1cc28a0b61448c9d9a6af7e7f4e87d40caff8370f1e4976f9ba6" + ], + "input_record": { + "commit": "95000da7cfdd034f2a86bdd5e11df3372bae5c0d", + "commits": 68, + "contributors": 7, + "difficulty": "easy", + "difficulty_code_lines": 921, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 921, + "difficulty_runtime_deps": 0, + "difficulty_score": 0.9642596301968491, + "difficulty_test_code_lines": 538, + "full_name": "kylelemons/go-gypsy", + "github_stars": 220, + "input_joern_zip": "go_joern/kylelemons__go-gypsy.zip", + "joern_status": true, + "joern_time": 5.27570437011309, + "language": "go", + "pb_match": [ + { + "pb_fullname": "sclevine/yj", + "rank": 191, + "similarity": 0.5237783789634705 + }, + { + "pb_fullname": "mikefarah/yq", + "rank": 732, + "similarity": 0.5162402391433716 + } + ], + "repo_age": 15.13, + "repo_path": "go/kylelemons__go-gypsy", + "source": "commit:95000da7cfdd034f2a86bdd5e11df3372bae5c0d", + "status": "done", + "url": "https://github.com/kylelemons/go-gypsy" + }, + "instance_id": "kylelemons__go-gypsy.95000da", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 2, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 2, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "coverage_path_attribution_failure" + } + ], + "repository": "kylelemons/go-gypsy" +} diff --git a/kylelemons--go-gypsy.95000da/tests/test.sh b/kylelemons--go-gypsy.95000da/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kylelemons--go-gypsy.95000da/tests/workspace.tar.gz b/kylelemons--go-gypsy.95000da/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3f88ec8dfcfee6004b4e5a1b76bfe1d5babe6281 --- /dev/null +++ b/kylelemons--go-gypsy.95000da/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5114fecd296f00aa2ead0dcac79dca01fe9ed147cdc6f4565e55c80ea080c78 +size 1182 diff --git a/kyokomi--emoji.eb10848/environment/Dockerfile b/kyokomi--emoji.eb10848/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/kyokomi--emoji.eb10848/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kyokomi--emoji.eb10848/environment/download.sh b/kyokomi--emoji.eb10848/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..cb6d05f2b9d06c65dd773c851955666d3b74b920 --- /dev/null +++ b/kyokomi--emoji.eb10848/environment/download.sh @@ -0,0 +1,11 @@ +#!/bin/bash +# PROGRAMGYM download.sh for kyokomi/emoji. +# +# The selected example target (./example) depends only on the Go standard +# library (flag) and the in-repository package github.com/kyokomi/emoji/v2. It +# requires no external Go module downloads, no OS packages, and no external +# build tools, so there is nothing to prefetch. The local Go toolchain used by +# the base image performs the offline build in build.sh. This file stays a +# source-safe no-op placeholder that is valid to `source` from the repository +# root and exports no variables or caches. +: diff --git a/kyokomi--emoji.eb10848/environment/executable b/kyokomi--emoji.eb10848/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..8eb020788bd7b0903035df2687508dceae7af2fd --- /dev/null +++ b/kyokomi--emoji.eb10848/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37139ff680d1a6b84c8a7a730718ba128a79033275bffa8d128b24a0a81991ae +size 3034458 diff --git a/kyokomi--emoji.eb10848/environment/programgym-go.tar.gz b/kyokomi--emoji.eb10848/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kyokomi--emoji.eb10848/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kyokomi--emoji.eb10848/environment/workspace.tar.gz b/kyokomi--emoji.eb10848/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7e096e81b1c029c94ffad0dc379ecbe28ed4933e --- /dev/null +++ b/kyokomi--emoji.eb10848/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b7466ad9c4961f4818fa44127857a9120a6b452802a54369566fabfe0af472b +size 99645 diff --git a/kyokomi--emoji.eb10848/instruction.md b/kyokomi--emoji.eb10848/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kyokomi--emoji.eb10848/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kyokomi--emoji.eb10848/solution/solve.sh b/kyokomi--emoji.eb10848/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kyokomi--emoji.eb10848/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kyokomi--emoji.eb10848/task.toml b/kyokomi--emoji.eb10848/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ae553a0fae2a502ac438802b9f53a63aef10929f --- /dev/null +++ b/kyokomi--emoji.eb10848/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kyokomi--emoji.eb10848" +description = "Synthetic ProgramGym cleanroom reconstruction task for kyokomi/emoji" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "kyokomi__emoji.eb10848" +repository = "kyokomi/emoji" +commit = "eb108489069ff2953e6bb4fe471784e664563644" +language = "go" +difficulty = "easy" +difficulty_score = 1.9284470632091821 +test_branches = 4 +test_count = 1113 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kyokomi--emoji.eb10848/tests/Dockerfile b/kyokomi--emoji.eb10848/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_01.tar.gz b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5e85bf770b1a3b518181d9f263a90e37b5334afa --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:838d4b235a472980fa6f2e01b4885c9262e3ed9d62f0196d6aec4fd3d4129c77 +size 15965 diff --git a/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_02.tar.gz b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5c0be2f2b41e573548309e0f4d2aeefa63768997 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35275707672a7314195742d805c0e6de4474928c45f17182a9f5b7aeec0945ad +size 66066 diff --git a/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_03.tar.gz b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..761c9469ee014cb0c0971697e38785ede51dcf79 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2ab0cebda225c2d3f1eebcf23f5d90ef8b8a2d201a63455c60dd8b5757792fb +size 16291 diff --git a/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_04.tar.gz b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..44a0658a928d1b7d4848c003369de4d783182b91 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9e734eb1f12864671dc2b32dab1945a75cacaf59c7fde6fbb80561cd7af23b7 +size 6146 diff --git a/kyokomi--emoji.eb10848/tests/download.sh b/kyokomi--emoji.eb10848/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..cb6d05f2b9d06c65dd773c851955666d3b74b920 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/download.sh @@ -0,0 +1,11 @@ +#!/bin/bash +# PROGRAMGYM download.sh for kyokomi/emoji. +# +# The selected example target (./example) depends only on the Go standard +# library (flag) and the in-repository package github.com/kyokomi/emoji/v2. It +# requires no external Go module downloads, no OS packages, and no external +# build tools, so there is nothing to prefetch. The local Go toolchain used by +# the base image performs the offline build in build.sh. This file stays a +# source-safe no-op placeholder that is valid to `source` from the repository +# root and exports no variables or caches. +: diff --git a/kyokomi--emoji.eb10848/tests/executable b/kyokomi--emoji.eb10848/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..8eb020788bd7b0903035df2687508dceae7af2fd --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37139ff680d1a6b84c8a7a730718ba128a79033275bffa8d128b24a0a81991ae +size 3034458 diff --git a/kyokomi--emoji.eb10848/tests/programgym-go.tar.gz b/kyokomi--emoji.eb10848/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/kyokomi--emoji.eb10848/tests/programgym_evaluator.py b/kyokomi--emoji.eb10848/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kyokomi--emoji.eb10848/tests/programgym_task.json b/kyokomi--emoji.eb10848/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..9d34294df0e5cbcf74c3b2c7e2aeabbe1ce7ed05 --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/programgym_task.json @@ -0,0 +1,1294 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_boundaries.test_complex_sentences[100% :100: complete :check: :heavy_check_mark:-100% \\U0001f4af complete :check: \\u2714\\ufe0f ]", + "eval.tests.test_boundaries.test_complex_sentences[A :smile: a day keeps the :beer: away-A \\U0001f604 a day keeps the \\U0001f37a away]", + "eval.tests.test_boundaries.test_complex_sentences[I :heart: :pizza: on :saturday:!-I \\u2764\\ufe0f \\U0001f355 on :saturday:!]", + "eval.tests.test_boundaries.test_complex_sentences[Rocket :rocket: party :tada: :confetti_ball:-Rocket \\U0001f680 party \\U0001f389 \\U0001f38a ]", + "eval.tests.test_boundaries.test_complex_sentences[x:flag-us:y:flag-jp:z-x\\U0001f1fa\\U0001f1f8y\\U0001f1ef\\U0001f1f5z]", + "eval.tests.test_boundaries.test_empty_argument", + "eval.tests.test_boundaries.test_interleaved_flags_and_plain", + "eval.tests.test_boundaries.test_leading_whitespace", + "eval.tests.test_boundaries.test_long_no_emoji_input", + "eval.tests.test_boundaries.test_nested_colon_string", + "eval.tests.test_boundaries.test_trailing_lone_colon", + "eval.tests.test_boundaries.test_unknown_plus_known_mixed", + "eval.tests.test_cli_entry.test_default_flag_value", + "eval.tests.test_cli_entry.test_empty_flag_value", + "eval.tests.test_cli_entry.test_explicit_flag_value", + "eval.tests.test_cli_entry.test_flag_value_syntaxes[argv0-\\U0001f355 ]", + "eval.tests.test_cli_entry.test_flag_value_syntaxes[argv1-\\U0001f363 ]", + "eval.tests.test_cli_entry.test_flag_value_syntaxes[argv2-\\U0001f431 ]", + "eval.tests.test_cli_entry.test_help_long_flag", + "eval.tests.test_cli_entry.test_help_short_flag", + "eval.tests.test_cli_entry.test_last_flag_value_wins", + "eval.tests.test_cli_entry.test_missing_flag_argument_errors", + "eval.tests.test_cli_entry.test_positional_ignored_uses_default", + "eval.tests.test_cli_entry.test_unknown_flag_errors", + "eval.tests.test_cli_entry.test_usage_path_is_flagged", + "eval.tests.test_codepoint_composition.test_double_zwj_couple[:couple_mm:-\\U0001f468\\u200d\\u2764\\ufe0f\\u200d\\U0001f468 ]", + "eval.tests.test_codepoint_composition.test_double_zwj_couple[:couple_ww:-\\U0001f469\\u200d\\u2764\\ufe0f\\u200d\\U0001f469 ]", + "eval.tests.test_codepoint_composition.test_gender_signs_differ_across_tones[man]", + "eval.tests.test_codepoint_composition.test_gender_signs_differ_across_tones[woman]", + "eval.tests.test_codepoint_composition.test_gender_tone_embedded_in_sentence", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_man_tone1:-\\U0001f471\\U0001f3fb\\u200d\\u2642\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_man_tone2:-\\U0001f471\\U0001f3fc\\u200d\\u2642\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_man_tone3:-\\U0001f471\\U0001f3fd\\u200d\\u2642\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_man_tone4:-\\U0001f471\\U0001f3fe\\u200d\\u2642\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_man_tone5:-\\U0001f471\\U0001f3ff\\u200d\\u2642\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_woman_tone1:-\\U0001f471\\U0001f3fb\\u200d\\u2640\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_woman_tone2:-\\U0001f471\\U0001f3fc\\u200d\\u2640\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_woman_tone3:-\\U0001f471\\U0001f3fd\\u200d\\u2640\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_woman_tone4:-\\U0001f471\\U0001f3fe\\u200d\\u2640\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_gender_tone_zwj_sequence[:blond-haired_woman_tone5:-\\U0001f471\\U0001f3ff\\u200d\\u2640\\ufe0f ]", + "eval.tests.test_codepoint_composition.test_keycap_digits_span_full_decimal_set", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:eight:-8]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:five:-5]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:four:-4]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:nine:-9]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:seven:-7]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:six:-6]", + "eval.tests.test_codepoint_composition.test_keycap_remaining_digits[:zero:-0]", + "eval.tests.test_codepoint_composition.test_man_vs_woman_gender_zwj_differ", + "eval.tests.test_codepoint_composition.test_zwj_shaped_unknown_passthrough[:blond-haired_tone1:]", + "eval.tests.test_codepoint_composition.test_zwj_shaped_unknown_passthrough[:couplekiss_mm:]", + "eval.tests.test_codepoint_composition.test_zwj_shaped_unknown_passthrough[:couplekiss_ww:]", + "eval.tests.test_codepoint_composition.test_zwj_shaped_unknown_passthrough[:man_man_tone1:]", + "eval.tests.test_codepoint_composition.test_zwj_shaped_unknown_passthrough[:woman_man_tone5:]", + "eval.tests.test_colon_parsing.test_colon_delimited_nonemoji_pair", + "eval.tests.test_colon_parsing.test_continuity_colons[::-::]", + "eval.tests.test_colon_parsing.test_continuity_colons[:::-:::]", + "eval.tests.test_colon_parsing.test_continuity_colons[:::smile:::-::\\U0001f604 ::]", + "eval.tests.test_colon_parsing.test_continuity_colons[::smile:-:\\U0001f604 ]", + "eval.tests.test_colon_parsing.test_continuity_colons[word::smile:-word:\\U0001f604 ]", + "eval.tests.test_colon_parsing.test_leading_colon_then_space", + "eval.tests.test_colon_parsing.test_multiple_shortcodes[:beer::sushi:-\\U0001f37a \\U0001f363 ]", + "eval.tests.test_colon_parsing.test_multiple_shortcodes[:smile: and :smile:-\\U0001f604 and \\U0001f604 ]", + "eval.tests.test_colon_parsing.test_multiple_shortcodes[:smile::smile:-\\U0001f604 \\U0001f604 ]", + "eval.tests.test_colon_parsing.test_newline_passed_through", + "eval.tests.test_colon_parsing.test_repeated_fire_chain", + "eval.tests.test_colon_parsing.test_shortcode_hits_space_before_close", + "eval.tests.test_colon_parsing.test_tab_between_shortcodes_preserved", + "eval.tests.test_combination_interleaving.test_glyph_after_shortcode_passthrough", + "eval.tests.test_combination_interleaving.test_help_precedes_explicit_value", + "eval.tests.test_combination_interleaving.test_help_precedes_repeated_values", + "eval.tests.test_combination_interleaving.test_known_shortcode_glyph_and_unclosed_coexist", + "eval.tests.test_combination_interleaving.test_newline_between_two_shortcodes", + "eval.tests.test_combination_interleaving.test_regional_flag_pairs_adjacent[aa-zz-\\U0001f1e6\\U0001f1e6\\U0001f1ff\\U0001f1ff]", + "eval.tests.test_combination_interleaving.test_regional_flag_pairs_adjacent[fr-cn-\\U0001f1eb\\U0001f1f7\\U0001f1e8\\U0001f1f3]", + "eval.tests.test_combination_interleaving.test_regional_flag_pairs_adjacent[us-de-\\U0001f1fa\\U0001f1f8\\U0001f1e9\\U0001f1ea]", + "eval.tests.test_combination_interleaving.test_shortcode_then_newline_then_plain_text", + "eval.tests.test_combination_interleaving.test_tab_between_regional_flag_and_known_shortcode", + "eval.tests.test_combination_interleaving.test_two_regional_flags_adjacent", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[aa-\\U0001f1e6\\U0001f1e6]", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[oo-\\U0001f1f4\\U0001f1f4]", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[pp-\\U0001f1f5\\U0001f1f5]", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[qq-\\U0001f1f6\\U0001f1f6]", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[uu-\\U0001f1fa\\U0001f1fa]", + "eval.tests.test_flags.test_arbitrary_two_letter_pair_is_regional[zz-\\U0001f1ff\\U0001f1ff]", + "eval.tests.test_flags.test_flag_and_shortcode_together", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[au-\\U0001f1e6\\U0001f1fa ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[ba-\\U0001f1e7\\U0001f1e6 ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[bb-\\U0001f1e7\\U0001f1e7 ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[br-\\U0001f1e7\\U0001f1f7 ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[in-\\U0001f1ee\\U0001f1f3 ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[mx-\\U0001f1f2\\U0001f1fd ]", + "eval.tests.test_flags.test_known_flag_shortcode_is_padded[za-\\U0001f1ff\\U0001f1e6 ]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-1u:-:flag-1u:]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-:-:flag-:]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-Fr:-:flag-Fr:]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-US:-:flag-US:]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-u:-:flag-u:]", + "eval.tests.test_flags.test_malformed_flag_unchanged[:flag-usa:-:flag-usa:]", + "eval.tests.test_flags.test_mixed_known_and_regional_flags_in_sentence", + "eval.tests.test_flags.test_padded_flag_then_shortcode", + "eval.tests.test_flags.test_regional_flag_has_no_padding[cn-\\U0001f1e8\\U0001f1f3]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[de-\\U0001f1e9\\U0001f1ea]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[es-\\U0001f1ea\\U0001f1f8]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[fr-\\U0001f1eb\\U0001f1f7]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[gb-\\U0001f1ec\\U0001f1e7]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[it-\\U0001f1ee\\U0001f1f9]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[jp-\\U0001f1ef\\U0001f1f5]", + "eval.tests.test_flags.test_regional_flag_has_no_padding[us-\\U0001f1fa\\U0001f1f8]", + "eval.tests.test_flags.test_regional_flag_nowhere_in_code_map", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:+1:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:beer:-\\U0001f37a]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:beer_mug:-\\U0001f37a]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:grinning_face_with_smiling_eyes:-\\U0001f604]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:smile:-\\U0001f604]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:thumbs_up:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_alias_variants_map_to_same_emoji[:thumbsup:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:+1:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:-1:-\\U0001f44e]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:airplane:-\\u2708\\ufe0f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:beer:-\\U0001f37a]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:beers:-\\U0001f37b]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:bell:-\\U0001f514]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:cat:-\\U0001f431]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:clap:-\\U0001f44f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:coffee:-\\u2615]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:dog:-\\U0001f436]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:fire:-\\U0001f525]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:grinning:-\\U0001f600]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:heart:-\\u2764\\ufe0f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:joy:-\\U0001f602]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:pizza:-\\U0001f355]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:skull:-\\U0001f480]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:smile:-\\U0001f604]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:sparkles:-\\u2728]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:star:-\\u2b50]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:sushi:-\\U0001f363]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:tea:-\\U0001f375]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:thumbs_up:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_conversion[:thumbsup:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:+1:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:-1:-\\U0001f44e]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:airplane:-\\u2708\\ufe0f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:beer:-\\U0001f37a]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:beers:-\\U0001f37b]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:bell:-\\U0001f514]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:cat:-\\U0001f431]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:clap:-\\U0001f44f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:coffee:-\\u2615]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:dog:-\\U0001f436]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:fire:-\\U0001f525]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:grinning:-\\U0001f600]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:heart:-\\u2764\\ufe0f]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:joy:-\\U0001f602]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:pizza:-\\U0001f355]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:skull:-\\U0001f480]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:smile:-\\U0001f604]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:sparkles:-\\u2728]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:star:-\\u2b50]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:sushi:-\\U0001f363]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:tea:-\\U0001f375]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:thumbs_up:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_known_shortcode_embedded_in_sentence[:thumbsup:-\\U0001f44d]", + "eval.tests.test_known_shortcodes.test_padding_exactly_one_space", + "eval.tests.test_known_shortcodes.test_shortcode_repeated_many_times", + "eval.tests.test_multicodepoint_and_regional.test_distinct_skin_tone_pairs", + "eval.tests.test_multicodepoint_and_regional.test_keycap_shortcode_multi_codepoint[:asterisk:-*\\ufe0f\\u20e3]", + "eval.tests.test_multicodepoint_and_regional.test_keycap_shortcode_multi_codepoint[:hash:-#\\ufe0f\\u20e3]", + "eval.tests.test_multicodepoint_and_regional.test_keycap_shortcode_multi_codepoint[:one:-1\\ufe0f\\u20e3]", + "eval.tests.test_multicodepoint_and_regional.test_keycap_shortcode_multi_codepoint[:three:-3\\ufe0f\\u20e3]", + "eval.tests.test_multicodepoint_and_regional.test_keycap_shortcode_multi_codepoint[:two:-2\\ufe0f\\u20e3]", + "eval.tests.test_multicodepoint_and_regional.test_multi_codepoint_has_single_padding", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_and_flag_combinations[:beer::one: and :heart: tail:x-\\U0001f37a 1\\ufe0f\\u20e3 and \\u2764\\ufe0f tail:x]", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_and_flag_combinations[:copyright::flag-jp::two:-\\xa9\\ufe0f \\U0001f1ef\\U0001f1f52\\ufe0f\\u20e3 ]", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_and_flag_combinations[:flag-us::one:-\\U0001f1fa\\U0001f1f81\\ufe0f\\u20e3 ]", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_and_flag_combinations[:one::flag-us:-1\\ufe0f\\u20e3 \\U0001f1fa\\U0001f1f8]", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_and_flag_combinations[:wave_tone5::family_man_woman_girl_boy:-\\U0001f44b\\U0001f3ff \\U0001f468\\u200d\\U0001f469\\u200d\\U0001f467\\u200d\\U0001f466 ]", + "eval.tests.test_multicodepoint_and_regional.test_multicodepoint_inside_sentence", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[a]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[b]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[c]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[d]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[e]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[f]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[g]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[h]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[i]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[j]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[k]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[l]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[m]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[n]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[o]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[p]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[q]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[r]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[s]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[t]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[u]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[v]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[w]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[x]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[y]", + "eval.tests.test_multicodepoint_and_regional.test_regional_first_position_exhaustive[z]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[a]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[b]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[c]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[d]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[e]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[f]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[g]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[h]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[i]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[j]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[k]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[l]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[m]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[n]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[o]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[p]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[q]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[r]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[s]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[t]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[u]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[v]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[w]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[x]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[y]", + "eval.tests.test_multicodepoint_and_regional.test_regional_second_position_exhaustive[z]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:clap_tone5:-\\U0001f44f\\U0001f3ff]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:thumbsup_tone1:-\\U0001f44d\\U0001f3fb]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:wave_tone1:-\\U0001f44b\\U0001f3fb]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:wave_tone2:-\\U0001f44b\\U0001f3fc]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:wave_tone3:-\\U0001f44b\\U0001f3fd]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:wave_tone4:-\\U0001f44b\\U0001f3fe]", + "eval.tests.test_multicodepoint_and_regional.test_skin_tone_modified_hand[:wave_tone5:-\\U0001f44b\\U0001f3ff]", + "eval.tests.test_multicodepoint_and_regional.test_variation_selector_emoji[:copyright:-\\xa9\\ufe0f]", + "eval.tests.test_multicodepoint_and_regional.test_variation_selector_emoji[:heart:-\\u2764\\ufe0f]", + "eval.tests.test_multicodepoint_and_regional.test_variation_selector_emoji[:recycle:-\\u267b\\ufe0f]", + "eval.tests.test_multicodepoint_and_regional.test_variation_selector_emoji[:registered:-\\xae\\ufe0f]", + "eval.tests.test_multicodepoint_and_regional.test_variation_selector_emoji[:tm:-\\u2122\\ufe0f]", + "eval.tests.test_multicodepoint_and_regional.test_zwj_family_sequence[:family_man_woman_girl_boy:-\\U0001f468\\u200d\\U0001f469\\u200d\\U0001f467\\u200d\\U0001f466]", + "eval.tests.test_multicodepoint_and_regional.test_zwj_family_sequence[:woman_running_tone5:-\\U0001f3c3\\U0001f3ff\\u200d\\u2640\\ufe0f]", + "eval.tests.test_passthrough.test_closed_shorts_then_unclosed", + "eval.tests.test_passthrough.test_closed_with_trailing_char", + "eval.tests.test_passthrough.test_known_then_unclosed", + "eval.tests.test_passthrough.test_lone_colon_cli", + "eval.tests.test_passthrough.test_plain_text_unchanged[1234567890]", + "eval.tests.test_passthrough.test_plain_text_unchanged[emoji-like :text: but unknown]", + "eval.tests.test_passthrough.test_plain_text_unchanged[mixed case and spaces]", + "eval.tests.test_passthrough.test_plain_text_unchanged[no colons here at all]", + "eval.tests.test_passthrough.test_plain_text_unchanged[plain text only]", + "eval.tests.test_passthrough.test_plain_text_unchanged[punctuation: and, semicolons; and () parens]", + "eval.tests.test_passthrough.test_unclosed_colon_is_unchanged[:beer]", + "eval.tests.test_passthrough.test_unclosed_colon_is_unchanged[word :coffee]", + "eval.tests.test_passthrough.test_unclosed_colon_is_unchanged[x:beer]", + "eval.tests.test_passthrough.test_unknown_shortcode_passthrough[: invalid :]", + "eval.tests.test_passthrough.test_unknown_shortcode_passthrough[:ABC123:]", + "eval.tests.test_passthrough.test_unknown_shortcode_passthrough[:UNKNOWN:]", + "eval.tests.test_passthrough.test_unknown_shortcode_passthrough[:doesnotexist:]", + "eval.tests.test_passthrough.test_unknown_shortcode_passthrough[:no-good:]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[::1]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[a://b]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[http://example.com]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[https://a.b/c?q=1]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[time:123]", + "eval.tests.test_whitespace_and_passthrough.test_colon_tokens_pass_through[x:12y]", + "eval.tests.test_whitespace_and_passthrough.test_double_space_after_shortcode", + "eval.tests.test_whitespace_and_passthrough.test_ideographic_space_between_shortcodes", + "eval.tests.test_whitespace_and_passthrough.test_leading_vertical_tab_preserved", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[\\U0001f600 alone-grinning glyph]", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[\\u4f60\\u597d-CJK ideographs]", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[a \\U0001f680 b-rocket glyph]", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[caf\\xe9 t\\u0113a-accented runes]", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[hello \\U0001f37a world-beer glyph]", + "eval.tests.test_whitespace_and_passthrough.test_raw_emoji_and_multibyte_passthrough[mix \\U0001f44d thumbs-thumbs glyph]", + "eval.tests.test_whitespace_and_passthrough.test_raw_glyph_adjacent_to_shortcode", + "eval.tests.test_whitespace_and_passthrough.test_shortcode_terminated_by_form_feed_only", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u2000-en quad]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u2003-em space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u2008-punctuation space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u200a-hair space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u2028-line separator]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u2029-paragraph separator]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u202f-narrow no-break space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u205f-medium mathematical space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\u3000-ideographic space]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\x0b-vertical tab]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\x0c-form feed]", + "eval.tests.test_whitespace_and_passthrough.test_unicode_whitespace_terminates_shortcode[\\xa0-no-break space]", + "eval.tests.test_whitespace_and_passthrough.test_vtab_then_newline_after_shortcode", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u2000-en quad]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u2003-em space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u2008-punctuation space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u200a-hair space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u2028-line separator]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u2029-paragraph separator]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u202f-narrow no-break space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u205f-medium mathematical space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\u3000-ideographic space]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\x0b-vertical tab]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\x0c-form feed]", + "eval.tests.test_whitespace_and_passthrough.test_whitespace_terminates_mid_shortcode[\\xa0-no-break space]" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\U0001f37a-aliases0]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\U0001f44d-aliases1]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\U0001f4af-aliases2]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\U0001f4bf-aliases7]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\U0001f595-aliases5]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\u270c\\ufe0f-aliases3]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\u2b50-aliases4]", + "eval.tests.test_alias_behavior.test_alias_members_all_resolve_to_group_emoji[\\u2b55-aliases6]", + "eval.tests.test_alias_behavior.test_alias_pair_identical_bytes[:+1:-:thumbsup:]", + "eval.tests.test_alias_behavior.test_alias_pair_identical_bytes[:100:-:hundred_points:]", + "eval.tests.test_alias_behavior.test_alias_pair_identical_bytes[:beer:-:beer_mug:]", + "eval.tests.test_alias_behavior.test_alias_pair_identical_bytes[:o:-:hollow_red_circle:]", + "eval.tests.test_alias_behavior.test_alias_sets_are_large_and_nonempty", + "eval.tests.test_alias_behavior.test_shared_emoji_multi_code_lookup", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_colon_eof_edges[:::-:::-3a3a3a]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_colon_eof_edges[::hash:-:#\\ufe0f\\u20e3 -3a23efb88fe283a320]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_colon_eof_edges[abc:-abc:-6162633a]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_colon_eof_edges[abc::-abc::-6162633a3a]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_default_output_is_broader_than_padded_emoji", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_flag_double_dash_equals_value_form", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_flag_equals_value_form", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_no_flag_uses_default_beer_prose", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_terminates_token_literal[:beer\\xa0x-:beer\\xa0x-3a62656572c2a078]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_terminates_token_literal[:hash\\u3000z-:hash\\u3000z-3a68617368e380807a]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_terminates_token_literal[:rocket\\u2028y-:rocket\\u2028y-3a726f636b6574e280a879]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_terminates_token_literal[:smile\\u2003x-:smile\\u2003x-3a736d696c65e2808378]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_terminates_token_literal[a:heart\\u2003b-a:heart\\u2003b-613a6865617274e2808362]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_then_token_still_converts[:beer\\u3000:smile:-:beer\\u3000\\U0001f604 -3a62656572e38080f09f988420]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_non_ascii_whitespace_then_token_still_converts[:beer\\xa0:rocket:-:beer\\xa0\\U0001f680 -3a62656572c2a0f09f9a8020]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_positional_before_flag_keeps_default", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_repeated_e_flag_last_value_wins", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_unterminated_and_single_letter_flag_edges[:flag--:flag--3a666c61672d]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_unterminated_and_single_letter_flag_edges[:flag-u:-:flag-u:-3a666c61672d753a]", + "eval.tests.test_cli_forms_and_unicode_whitespace.test_unterminated_and_single_letter_flag_edges[x:flag-us-x:flag-us-783a666c61672d7573]", + "eval.tests.test_compile_behavior.test_adjacent_distinct_shortcodes_no_separator", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[: snowman2:]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[:%%literal%%:]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[::]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[:]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[:flag-us2:]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[:flag-with-wrong-count:]", + "eval.tests.test_compile_behavior.test_degenerate_or_unknown_shortcodes_passthrough[:no_emoji_here:]", + "eval.tests.test_compile_behavior.test_empty_input_prints_nothing", + "eval.tests.test_compile_behavior.test_empty_shortcode_colon_passthrough", + "eval.tests.test_compile_behavior.test_flag_lowercase_regional_indicators", + "eval.tests.test_compile_behavior.test_flag_wrong_country_shape_passthrough[:flag-GB:]", + "eval.tests.test_compile_behavior.test_flag_wrong_country_shape_passthrough[:flag-Us:]", + "eval.tests.test_compile_behavior.test_flag_wrong_country_shape_passthrough[:flag-us-extra85:]", + "eval.tests.test_compile_behavior.test_flag_wrong_country_shape_passthrough[:flag-usa:]", + "eval.tests.test_compile_behavior.test_keycap_asterisk_uses_map_lookup", + "eval.tests.test_compile_behavior.test_known_shortcode_that_resembles_unknown_is_mapped", + "eval.tests.test_compile_behavior.test_multiple_shortcodes_accumulate", + "eval.tests.test_compile_behavior.test_padding_between_repeated_shortcodes", + "eval.tests.test_compile_behavior.test_partial_multi_token_conversion", + "eval.tests.test_compile_behavior.test_registered_flag_key_gets_map_emoji_and_padding", + "eval.tests.test_compile_behavior.test_registered_shortcode_reaches_map_not_flag_branch", + "eval.tests.test_compile_behavior.test_shortcode_within_text", + "eval.tests.test_compile_behavior.test_unknown_shortcode_passthrough", + "eval.tests.test_compile_behavior.test_unregistered_flag_pair_renders_regional_indicators[:flag-aa:]", + "eval.tests.test_compile_behavior.test_unregistered_flag_pair_renders_regional_indicators[:flag-ah:]", + "eval.tests.test_compile_behavior.test_unregistered_flag_pair_renders_regional_indicators[:flag-wz:]", + "eval.tests.test_compile_behavior.test_unregistered_flag_pair_renders_regional_indicators[:flag-xy:]", + "eval.tests.test_compile_behavior.test_unregistered_flag_pair_renders_regional_indicators[:flag-zz:]", + "eval.tests.test_compile_behavior.test_unterminated_shortcode_passthrough", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:1234:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:1st_place_medal:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:2nd_place_medal:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:3rd_place_medal:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:8ball:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:accept:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:aries:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:baby_bottle:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:blue_heart:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:cancer:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:curly_loop:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:eu:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:flag_in_hole:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:globe_with_meridians:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:input_latin_uppercase:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:keycap_#:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:keycap_0:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:keycap_1:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:love_letter:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:no_mobile_phones:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:o2:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:sagittarius:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:telephone:]", + "eval.tests.test_forward_lookup.test_diverse_registered_shortcodes[:uk:]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:100:-\\U0001f4af]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:1234:-\\U0001f522]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:Japanese_vacancy_button:-\\U0001f233]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:accept:-\\U0001f251]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:airplane_arriving:-\\U0001f6ec]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:anchor:-\\u2693]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:backhand_index_pointing_left:-\\U0001f448]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:bald_man:-\\U0001f468\\u200d\\U0001f9b2]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:battery:-\\U0001f50b]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:beer:-\\U0001f37a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:bell:-\\U0001f514]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:bookmark_tabs:-\\U0001f4d1]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:briefcase:-\\U0001f4bc]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:calendar:-\\U0001f4c6]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:car:-\\U0001f697]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:chart_increasing:-\\U0001f4c8]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:check_mark_button:-\\u2705]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:clapping_hands:-\\U0001f44f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:clock11:-\\U0001f55a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:clock230:-\\U0001f55d]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:cocos_islands:-\\U0001f1e8\\U0001f1e8]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:cold_face:-\\U0001f976]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:collision:-\\U0001f4a5]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:confounded_face:-\\U0001f616]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:copyright:-\\xa9\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:cowboy_hat_face:-\\U0001f920]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:cricket_bat_and_ball:-\\U0001f3cf]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:crossed_fingers:-\\U0001f91e]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:crystal_ball:-\\U0001f52e]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:curly_loop:-\\u27b0]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:date:-\\U0001f4c5]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:desktop_computer:-\\U0001f5a5\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:disguised_face:-\\U0001f978]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:dog_face:-\\U0001f436]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:email:-\\u2709\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:eyes:-\\U0001f440]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:face_with_diagonal_mouth:-\\U0001fae4]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:family_man_woman_girl:-\\U0001f468\\u200d\\U0001f469\\u200d\\U0001f467]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fingers_crossed_tone1:-\\U0001f91e\\U0001f3fb]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fire:-\\U0001f525]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fist_tone2:-\\u270a\\U0001f3fc]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:five:-5\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag-br:-\\U0001f1e7\\U0001f1f7]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag-ge:-\\U0001f1ec\\U0001f1ea]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag-ug:-\\U0001f1fa\\U0001f1ec]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_Equatorial_Guinea:-\\U0001f1ec\\U0001f1f6]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_Faroe_Islands:-\\U0001f1eb\\U0001f1f4]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_Gibraltar:-\\U0001f1ec\\U0001f1ee]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_bq:-\\U0001f1e7\\U0001f1f6]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_ca:-\\U0001f1e8\\U0001f1e6]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_dm:-\\U0001f1e9\\U0001f1f2]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_il:-\\U0001f1ee\\U0001f1f1]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_nl:-\\U0001f1f3\\U0001f1f1]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:flag_ve:-\\U0001f1fb\\U0001f1ea]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:folded_hands:-\\U0001f64f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fork_and_knife:-\\U0001f374]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fu:-\\U0001f595]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:fuelpump:-\\u26fd]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:gem_stone:-\\U0001f48e]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:globe_showing_Europe-Africa:-\\U0001f30d]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:goblin:-\\U0001f47a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:hash:-#\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:heart:-\\u2764\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:heart_on_fire:-\\u2764\\ufe0f\\u200d\\U0001f525]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:horse_racing_tone3:-\\U0001f3c7\\U0001f3fd]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:hot_face:-\\U0001f975]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:hourglass_done:-\\u231b]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:hundred_points:-\\U0001f4af]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:japanese_goblin:-\\U0001f47a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:keycap_*:-*\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:keycap_star:-*\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:laptop:-\\U0001f4bb]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:leg:-\\U0001f9b5]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:magnifying_glass_tilted_left:-\\U0001f50d]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man-gesturing-no:-\\U0001f645\\u200d\\u2642\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_and_woman_holding_hands:-\\U0001f46b]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_factory_worker_tone2:-\\U0001f468\\U0001f3fc\\u200d\\U0001f3ed]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_golfing:-\\U0001f3cc\\ufe0f\\u200d\\u2642\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_kneeling_facing_right:-\\U0001f9ce\\u200d\\u2642\\ufe0f\\u200d\\u27a1\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_lifting_weights_tone1:-\\U0001f3cb\\U0001f3fb\\u200d\\u2642\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:man_playing_water_polo:-\\U0001f93d\\u200d\\u2642\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:manual_wheelchair:-\\U0001f9bd]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:mechanic:-\\U0001f9d1\\u200d\\U0001f527]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:money_bag:-\\U0001f4b0]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:moneybag:-\\U0001f4b0]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:musical_note:-\\U0001f3b5]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:ng:-\\U0001f196]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:o:-\\u2b55]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:ok_hand:-\\U0001f44c]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:open_book:-\\U0001f4d6]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:parking:-\\U0001f17f\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:partly_sunny:-\\u26c5]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:pencil:-\\u270f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:person_biking:-\\U0001f6b4]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:person_pouting:-\\U0001f64e]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:pig_face:-\\U0001f437]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:prohibited:-\\U0001f6ab]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:pushpin:-\\U0001f4cc]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:recycling_symbol:-\\u267b]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:red_exclamation_mark:-\\u2757]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:red_hair:-\\U0001f9b0]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:red_heart:-\\u2764]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:red_question_mark:-\\u2753]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:registered:-\\xae\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:repeat_one:-\\U0001f502]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:rice:-\\U0001f35a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:rocket:-\\U0001f680]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:ru:-\\U0001f1f7\\U0001f1fa]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:santa_tone5:-\\U0001f385\\U0001f3ff]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:scissors:-\\u2702\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:sewing_needle:-\\U0001faa1]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:smile:-\\U0001f604]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:smiling_face_with_sunglasses:-\\U0001f60e]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:soccer_ball:-\\u26bd]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:star:-\\u2b50]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:stop_sign:-\\U0001f6d1]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:sunny:-\\u2600\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:telephone_receiver:-\\U0001f4de]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:thinking_face:-\\U0001f914]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:thumbsup:-\\U0001f44d]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:trade_mark:-\\u2122]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:tram:-\\U0001f68a]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:v:-\\u270c\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:vanuatu:-\\U0001f1fb\\U0001f1fa]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:video_game:-\\U0001f3ae]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:warning:-\\u26a0\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:wave_tone1:-\\U0001f44b\\U0001f3fb]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:waving_hand:-\\U0001f44b]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:white_medium_small_square:-\\u25fd]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman-frowning:-\\U0001f64d\\u200d\\u2640\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman_frowning_tone3:-\\U0001f64d\\U0001f3fd\\u200d\\u2640\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman_getting_haircut_tone4:-\\U0001f487\\U0001f3fe\\u200d\\u2640\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman_scientist_tone5:-\\U0001f469\\U0001f3ff\\u200d\\U0001f52c]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman_shrugging_tone1:-\\U0001f937\\U0001f3fb\\u200d\\u2640\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:woman_technologist:-\\U0001f469\\u200d\\U0001f4bb]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:world_map:-\\U0001f5fa\\ufe0f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:worried:-\\U0001f61f]", + "eval.tests.test_forward_lookup.test_forward_lookup_exact[:yum:-\\U0001f60b]", + "eval.tests.test_forward_lookup.test_many_distinct_forward_keys_produce_distinct_emojis", + "eval.tests.test_forward_lookup.test_registered_sample_is_truly_replaced", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:100:-\\U0001f4af]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:ab:-\\U0001f18e]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:cd:-\\U0001f4bf]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:cl:-\\U0001f191]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:fu:-\\U0001f595]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:hash:-#\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:keycap_*:-*\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:o:-\\u2b55]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:ok:-\\U0001f197]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:on:-\\U0001f51b]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:plus:-\\u2795]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:snowman2:-\\u2603]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:three:-3\\ufe0f\\u20e3]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:up:-\\U0001f199]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:v:-\\u270c\\ufe0f]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:vs:-\\U0001f19a]", + "eval.tests.test_forward_lookup.test_short_and_atypical_shortcodes[:x:-\\u274c]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_digit_keycap_and_colon_chain_edges[:100:x-\\U0001f4af x-f09f92af2078]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_digit_keycap_and_colon_chain_edges[::::-::::-3a3a3a3a]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_digit_keycap_and_colon_chain_edges[:hash::100:-#\\ufe0f\\u20e3 \\U0001f4af -23efb88fe283a320f09f92af20]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_digit_keycap_and_colon_chain_edges[x::y:beer:-x::y:beer:-783a3a793a626565723a]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_flag_registry_adjacency_no_separator[:beer::flag-us:-\\U0001f37a \\U0001f1fa\\U0001f1f8-f09f8dba20f09f87baf09f87b8]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_flag_registry_adjacency_no_separator[:flag-us::beer:-\\U0001f1fa\\U0001f1f8\\U0001f37a -f09f87baf09f87b8f09f8dba20]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_flag_registry_adjacency_no_separator[x:flag-us:y-x\\U0001f1fa\\U0001f1f8y-78f09f87baf09f87b879]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_matches_forward_conversion", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_passes_through_unchanged[\\U0001f37a :beer: \\U0001f37a-\\U0001f37a \\U0001f37a \\U0001f37a-f09f8dba20f09f8dba2020f09f8dba]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_passes_through_unchanged[\\U0001f37a :beer:-\\U0001f37a \\U0001f37a -f09f8dba20f09f8dba20]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_passes_through_unchanged[\\U0001f600\\U0001f680-\\U0001f600\\U0001f680-f09f9880f09f9a80]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_passes_through_unchanged[a\\U0001f600b :smile: c-a\\U0001f600b \\U0001f604 c-61f09f98806220f09f9884202063]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_literal_emoji_passes_through_unchanged[x\\U0001f37a y :beer: z-x\\U0001f37a y \\U0001f37a z-78f09f8dba207920f09f8dba20207a]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_mixed_case_shortcode_not_folded", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_non_space_whitespace_terminates_token_literal[:beer\\nx-:beer\\nx-3a626565720a78]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_non_space_whitespace_terminates_token_literal[:beer\\tbeer:-:beer\\tbeer:-3a6265657209626565723a]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_non_space_whitespace_terminates_token_literal[:smile\\rx:-:smile\\rx:-3a736d696c650d783a]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_uppercase_key_variant_passes_through[:BEER:]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_uppercase_key_variant_passes_through[:Beer:]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_uppercase_key_variant_passes_through[:FlAg-us:]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_uppercase_key_variant_passes_through[:HASH:]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_uppercase_key_variant_passes_through[:Smile:]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_whitespace_between_tokens_still_converts_registered[:beer:\\n:smile:-\\U0001f37a \\n\\U0001f604 -f09f8dba200af09f988420]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_whitespace_between_tokens_still_converts_registered[:smile\\t:beer:-:smile\\t\\U0001f37a -3a736d696c6509f09f8dba20]", + "eval.tests.test_literal_emoji_and_whitespace_edges.test_whitespace_between_tokens_still_converts_registered[a \\t :beer:-a \\t \\U0001f37a -61200920f09f8dba20]", + "eval.tests.test_map_structure.test_binary_serves_nonempty_unique_emoji_across_sample", + "eval.tests.test_map_structure.test_forward_map_is_large_and_served_by_binary", + "eval.tests.test_map_structure.test_padding_constant_is_single_space", + "eval.tests.test_map_structure.test_resource_files_present_and_readable", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:+1:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:-1:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:100:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:1st_place_medal:0]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:1st_place_medal:1]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:8ball:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:ATM_sign:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:Aquarius:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:Christmas_tree:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:accept:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:bagel:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:dog_face:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:mango:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:shallow_pan_of_food:]", + "eval.tests.test_map_structure.test_resource_row_served_verbatim[:woman_technologist:]", + "eval.tests.test_multicodepoint_forward.test_adjacent_conversion_without_separator_padding", + "eval.tests.test_multicodepoint_forward.test_echo_adjacent_to_conversion_ordering", + "eval.tests.test_multicodepoint_forward.test_flag_converted_mid_text", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:couple_with_heart_woman_man:-\\U0001f469\\u200d\\u2764\\ufe0f\\u200d\\U0001f468 -f09f91a9e2808de29da4efb88fe2808df09f91a820]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:family_man_woman_girl_boy:-\\U0001f468\\u200d\\U0001f469\\u200d\\U0001f467\\u200d\\U0001f466 -f09f91a8e2808df09f91a9e2808df09f91a7e2808df09f91a620]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:flag-ac:-\\U0001f1e6\\U0001f1e8 -f09f87a6f09f87a820]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:hash:-#\\ufe0f\\u20e3 -23efb88fe283a320]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:keycap_8:-8\\ufe0f\\u20e3 -38efb88fe283a320]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:man_teacher:-\\U0001f468\\u200d\\U0001f3eb -f09f91a8e2808df09f8fab20]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:rainbow_flag:-\\U0001f3f3\\ufe0f\\u200d\\U0001f308 -f09f8fb3efb88fe2808df09f8c8820]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:weight_lifting:-\\U0001f3cb\\ufe0f -f09f8f8befb88f20]", + "eval.tests.test_multicodepoint_forward.test_forward_multicodepoint_emoji_exact[:woman_technologist:-\\U0001f469\\u200d\\U0001f4bb -f09f91a9e2808df09f92bb20]", + "eval.tests.test_multicodepoint_forward.test_more_multicodepoint_registered_keys[:100:-\\U0001f4af -f09f92af20]", + "eval.tests.test_multicodepoint_forward.test_more_multicodepoint_registered_keys[:clapping_hands:-\\U0001f44f -f09f918f20]", + "eval.tests.test_multicodepoint_forward.test_more_multicodepoint_registered_keys[:folded_hands:-\\U0001f64f -f09f998f20]", + "eval.tests.test_multicodepoint_forward.test_more_multicodepoint_registered_keys[:ok_hand:-\\U0001f44c -f09f918c20]", + "eval.tests.test_multicodepoint_forward.test_more_multicodepoint_registered_keys[:watermelon:-\\U0001f349 -f09f8d8920]", + "eval.tests.test_multicodepoint_forward.test_prose_multi_token_conversion_order", + "eval.tests.test_multicodepoint_forward.test_repeated_leading_colon_recursion", + "eval.tests.test_multicodepoint_forward.test_space_terminates_token_leaving_literal" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[1]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[2]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[3]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[4]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[6]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[7]", + "eval.tests.test_colon_sweep.test_colons_around_real_code_keep_literal_surround[8]", + "eval.tests.test_colon_sweep.test_interleaved_colon_code_pattern", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[1]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[2]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[3]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[4]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[6]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[7]", + "eval.tests.test_colon_sweep.test_n_colons_stay_literal[8]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[::smile::beer:-3af09f988420f09f8dba20-leading literal colon then two codes]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[:flag-us: and :flag-jp:-f09f87baf09f87b820616e6420f09f87aff09f87b5-two flags separated by text, no padding on flag branch]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[:flag-us::flag-jp:-f09f87baf09f87b8f09f87aff09f87b5-two flags concatenated with no separator]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[:flag-us::flag-us:-f09f87baf09f87b8f09f87baf09f87b8-same non-key flag twice concatenated, no padding]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[:smile:::beer::100:-f09f9884203af09f8dba20f09f92af20-three codes with a literal colon from the :: continuity rule]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[:smile:===:beer:-f09f9884203d3d3df09f8dba20-codes separated by literal === punctuation]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[Team :flag-gb: wins :trophy:-5465616d20f09f87acf09f87a72077696e7320f09f8f8620-flag then trophy in one sentence]", + "eval.tests.test_composite_deep.test_composite_deep_expansion[price: :dollar: $100 :boom:-70726963653a20f09f92b520202431303020f09f92a520-mixed literal text, dollar, then boom]", + "eval.tests.test_composite_deep.test_single_codemap_code_with_padding[:arrow_up:-e2ac86efb88f20-arrow up, VS16 + padding]", + "eval.tests.test_composite_deep.test_single_codemap_code_with_padding[:boom:-f09f92a520-bangbang, codemap-key with padding]", + "eval.tests.test_composite_deep.test_single_codemap_code_with_padding[:dollar:-f09f92b520-dollar banknote, codemap-key with padding]", + "eval.tests.test_composite_deep.test_single_codemap_code_with_padding[:smile:-f09f988420-smile, codemap-key with padding]", + "eval.tests.test_composite_deep.test_single_codemap_code_with_padding[:trophy:-f09f8f8620-trophy, codemap-key with padding]", + "eval.tests.test_composite_text.test_code_at_start_and_end", + "eval.tests.test_composite_text.test_composite_text_expansion[ :beer: -2020f09f8dba202020-leading and trailing spaces preserved around padding]", + "eval.tests.test_composite_text.test_composite_text_expansion[::beer::-3af09f8dba203a-leading literal colon then code then trailing colon]", + "eval.tests.test_composite_text.test_composite_text_expansion[:smile: :beer:-f09f98842020f09f8dba20-code then space then code]", + "eval.tests.test_composite_text.test_composite_text_expansion[A :smile: :beer: B-4120f09f98842020f09f8dba202042-two adjacent codes each padded]", + "eval.tests.test_composite_text.test_composite_text_expansion[A :smile: a day-4120f09f988420206120646179-code in the middle of a sentence]", + "eval.tests.test_composite_text.test_composite_text_expansion[a :pizza: and :sushi:!!-6120f09f8d952020616e6420f09f8da3202121-sentence with 'and' and punctuation after a code]", + "eval.tests.test_composite_text.test_embedded_tab_and_newline", + "eval.tests.test_default_and_basic.test_double_dash_long_flag", + "eval.tests.test_default_and_basic.test_e_autos_to_beer", + "eval.tests.test_default_and_basic.test_e_star_dash_value", + "eval.tests.test_default_and_basic.test_e_true_false_strings", + "eval.tests.test_default_and_basic.test_empty_e_prints_nothing", + "eval.tests.test_default_and_basic.test_multiple_e_last_wins", + "eval.tests.test_default_and_basic.test_no_argument_prints_default_beer_message", + "eval.tests.test_default_and_basic.test_no_trailing_newline", + "eval.tests.test_default_and_basic.test_plain_text_passthrough", + "eval.tests.test_default_and_basic.test_single_known_code_beer", + "eval.tests.test_default_and_basic.test_single_known_code_smile", + "eval.tests.test_errors_and_flags.test_double_dash_uses_default", + "eval.tests.test_errors_and_flags.test_equals_form_then_value_form", + "eval.tests.test_errors_and_flags.test_help_long_flag", + "eval.tests.test_errors_and_flags.test_help_mentions_default_value", + "eval.tests.test_errors_and_flags.test_help_short_flag", + "eval.tests.test_errors_and_flags.test_missing_flag_argument_errors", + "eval.tests.test_errors_and_flags.test_repeated_flag_last_wins_form", + "eval.tests.test_errors_and_flags.test_undefined_long_flag_errors", + "eval.tests.test_errors_and_flags.test_undefined_short_flag_errors", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:AB_button_(blood_type):-f09f868e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:A_button_(blood_type):-f09f85b020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:BACK_arrow:-f09f949920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:B_button_(blood_type):-f09f85b120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:CL_button:-f09f869120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:COOL_button:-f09f869220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Capricorn:-e2999120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:END_arrow:-f09f949a20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:FREE_button:-f09f869320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ID_button:-f09f869420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_acceptable_button:-f09f899120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_application_button:-f09f88b820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_bargain_button:-f09f899020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_castle:-f09f8faf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_congratulations_button:-e38a9720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_discount_button:-f09f88b920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_dolls:-f09f8e8e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_free_of_charge_button:-f09f889a20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_here_button:-f09f888120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_monthly_amount_button:-f09f88b720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_no_vacancy_button:-f09f88b520]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_not_free_of_charge_button:-f09f88b620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_open_for_business_button:-f09f88ba20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_passing_grade_button:-f09f88b420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_post_office:-f09f8fa320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_prohibited_button:-f09f88b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_reserved_button:-f09f88af20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_secret_button:-e38a9920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_service_charge_button:-f09f888220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_symbol_for_beginner:-f09f94b020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Japanese_vacancy_button:-f09f88b320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Leo:-e2998c20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Libra:-e2998e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Mrs._Claus:-f09fa4b620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:NEW_button:-f09f869520]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:NG_button:-f09f869620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:OK_button:-f09f869720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:OK_hand:-f09f918c20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ON!_arrow:-f09f949b20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:O_button_(blood_type):-f09f85be20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Ophiuchus:-e29b8e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:P_button:-f09f85bf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Pisces:-e2999320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:SOON_arrow:-f09f949c20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:SOS_button:-f09f869820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Sagittarius:-e2999020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Santa_Claus:-f09f8e8520]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Scorpio:-e2998f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Statue_of_Liberty:-f09f97bd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:T-Rex:-f09fa69620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:TOP_arrow:-f09f949d20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Taurus:-e2998920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Tokyo_tower:-f09f97bc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:UP!_button:-f09f869920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:VS_button:-f09f869a20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:Virgo:-e2998d20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ZZZ:-f09f92a420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ab:-f09f868e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:abacus:-f09fa7ae20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:abc:-f09f94a420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:abcd:-f09f94a120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:accept:-f09f899120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:accordion:-f09faa9720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adhesive_bandage:-f09fa9b920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:admission_tickets:-f09f8e9fefb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult:-f09fa79120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult_tone1:-f09fa791f09f8fbb20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult_tone2:-f09fa791f09f8fbc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult_tone3:-f09fa791f09f8fbd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult_tone4:-f09fa791f09f8fbe20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:adult_tone5:-f09fa791f09f8fbf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:aerial_tramway:-f09f9aa120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:afghanistan:-f09f87a6f09f87ab20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:airplane:-e29c88efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:airplane_arrival:-f09f9bac20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:airplane_arriving:-f09f9bac20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:airplane_departure:-f09f9bab20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:airplane_small:-f09f9ba920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:aland_islands:-f09f87a6f09f87bd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:alarm_clock:-e28fb020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:albania:-f09f87a6f09f87b120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:alembic:-e29a97efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:algeria:-f09f87a9f09f87bf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:alien:-f09f91bd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:alien_monster:-f09f91be20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ambulance:-f09f9a9120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:american_football:-f09f8f8820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:american_samoa:-f09f87a6f09f87b820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:amphora:-f09f8fba20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anatomical_heart:-f09fab8020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anchor:-e29a9320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:andorra:-f09f87a6f09f87a920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel:-f09f91bc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel_tone1:-f09f91bcf09f8fbb20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel_tone2:-f09f91bcf09f8fbc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel_tone3:-f09f91bcf09f8fbd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel_tone4:-f09f91bcf09f8fbe20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angel_tone5:-f09f91bcf09f8fbf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anger:-f09f92a220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anger_right:-f09f97af20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anger_symbol:-f09f92a220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angola:-f09f87a6f09f87b420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angry_face:-f09f98a020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:angry_face_with_horns:-f09f91bf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anguilla:-f09f87a6f09f87ae20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anguished:-f09f98a720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anguished_face:-f09f98a720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ant:-f09f909c20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:antarctica:-f09f87a6f09f87b620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:antenna_bars:-f09f93b620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:antigua_barbuda:-f09f87a6f09f87ac20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:anxious_face_with_sweat:-f09f98b020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:apple:-f09f8d8e20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:aquarius:-e2999220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:argentina:-f09f87a6f09f87b720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:aries:-e2998820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:armenia:-f09f87a6f09f87b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_backward:-e29780efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_double_down:-e28fac20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_double_up:-e28fab20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_down:-e2ac87efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_down_small:-f09f94bd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_forward:-e296b6efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_heading_down:-e2a4b5efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_heading_up:-e2a4b4efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_left:-e2ac85efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_lower_left:-e28699efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_lower_right:-e28698efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_right:-e29ea1efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_right_hook:-e286aaefb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_up:-e2ac86efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_up_down:-e28695efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_up_small:-f09f94bc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_upper_left:-e28696efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrow_upper_right:-e28697efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrows_clockwise:-f09f948320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:arrows_counterclockwise:-f09f948420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:art:-f09f8ea820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:articulated_lorry:-f09f9a9b20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:artificial_satellite:-f09f9bb0efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:artist:-f09fa791e2808df09f8ea820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:artist_palette:-f09f8ea820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:aruba:-f09f87a6f09f87bc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ascension_island:-f09f87a6f09f87a820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:asterisk:-2aefb88fe283a320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:astonished:-f09f98b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:astonished_face:-f09f98b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:astronaut:-f09fa791e2808df09f9a8020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:athletic_shoe:-f09f919f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:atm:-f09f8fa720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:atom:-e29a9b20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:atom_symbol:-e29a9befb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:australia:-f09f87a6f09f87ba20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:austria:-f09f87a6f09f87b920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:auto_rickshaw:-f09f9bba20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:automobile:-f09f9a9720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:avocado:-f09fa59120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:axe:-f09faa9320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:azerbaijan:-f09f87a6f09f87bf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby:-f09f91b620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_angel:-f09f91bc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_bottle:-f09f8dbc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_chick:-f09f90a420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_symbol:-f09f9abc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_tone1:-f09f91b6f09f8fbb20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_tone2:-f09f91b6f09f8fbc20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_tone3:-f09f91b6f09f8fbd20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_tone4:-f09f91b6f09f8fbe20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baby_tone5:-f09f91b6f09f8fbf20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:back:-f09f949920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:backhand_index_pointing_down:-f09f918720]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:backhand_index_pointing_left:-f09f918820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:backhand_index_pointing_right:-f09f918920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:backhand_index_pointing_up:-f09f918620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:backpack:-f09f8e9220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bacon:-f09fa59320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:badger:-f09fa6a120]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:badminton:-f09f8fb820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:badminton_racquet_and_shuttlecock:-f09f8fb820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bagel:-f09fa5af20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baggage_claim:-f09f9b8420]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:baguette_bread:-f09fa59620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bahamas:-f09f87a7f09f87b820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bahrain:-f09f87a7f09f87ad20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:balance_scale:-e29a9620]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bald:-f09fa6b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bald_man:-f09f91a8e2808df09fa6b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bald_person:-f09fa791e2808df09fa6b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bald_woman:-f09f91a9e2808df09fa6b220]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ballet_shoes:-f09fa9b020]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:balloon:-f09f8e8820]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ballot_box:-f09f97b320]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ballot_box_with_ballot:-f09f97b3efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:ballot_box_with_check:-e29891efb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bamboo:-f09f8e8d20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:banana:-f09f8d8c20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bangbang:-e280bcefb88f20]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bangladesh:-f09f87a7f09f87a920]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:banjo:-f09faa9520]", + "eval.tests.test_extended_codemap_codes.test_extended_known_code_byte_output[:bank:-f09f8fa620]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[ae-f09f87a6f09f87aa20-United Arab Emirates]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[ar-f09f87a6f09f87b720-Argentina]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[au-f09f87a6f09f87ba20-Australia]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[ca-f09f87a8f09f87a620-Canada]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[cl-f09f87a8f09f87b120-Chile]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[dk-f09f87a9f09f87b020-Denmark]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[eg-f09f87aaf09f87ac20-Egypt]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[fi-f09f87abf09f87ae20-Finland]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[gr-f09f87acf09f87b720-Greece]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[il-f09f87aef09f87b120-Israel]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[ma-f09f87b2f09f87a620-Morocco]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[mx-f09f87b2f09f87bd20-Mexico]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[ng-f09f87b3f09f87ac20-Nigeria]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[no-f09f87b3f09f87b420-Norway]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[pe-f09f87b5f09f87aa20-Peru]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[pl-f09f87b5f09f87b120-Poland]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[pt-f09f87b5f09f87b920-Portugal]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[sa-f09f87b8f09f87a620-Saudi Arabia]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[se-f09f87b8f09f87aa20-Sweden]", + "eval.tests.test_extended_flag_codes.test_flag_codemap_key_pair_has_padding[tr-f09f87b9f09f87b720-Turkey]", + "eval.tests.test_extended_flag_codes.test_flag_non_key_pair_no_padding[es-f09f87aaf09f87b8-Spain via flag branch, no padding]", + "eval.tests.test_extended_flag_codes.test_flag_non_key_pair_no_padding[kr-f09f87b0f09f87b7-South Korea via flag branch, no padding]", + "eval.tests.test_flag_codes.test_flag_code_that_is_codemap_key_gets_padding[br-f09f87a7f09f87b720-brazil]", + "eval.tests.test_flag_codes.test_flag_code_that_is_codemap_key_gets_padding[in-f09f87aef09f87b320-india]", + "eval.tests.test_flag_codes.test_flag_code_that_is_codemap_key_gets_padding[ng-f09f87b3f09f87ac20-nigeria]", + "eval.tests.test_flag_codes.test_flag_embedded_in_text", + "eval.tests.test_flag_codes.test_flag_two_lowercase_indicators[aa-f09f87a6f09f87a6-alpha-alpha both A]", + "eval.tests.test_flag_codes.test_flag_two_lowercase_indicators[gb-f09f87acf09f87a7-UK via flag branch]", + "eval.tests.test_flag_codes.test_flag_two_lowercase_indicators[jp-f09f87aff09f87b5-Japan via flag branch]", + "eval.tests.test_flag_codes.test_flag_two_lowercase_indicators[us-f09f87baf09f87b8-USA]", + "eval.tests.test_flag_codes.test_flag_two_lowercase_indicators[zz-f09f87bff09f87bf-zz pair maps to Z Z regional indicators]", + "eval.tests.test_flag_codes.test_flag_us_exact", + "eval.tests.test_flag_codes.test_flag_us_trailing_space_input", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:Flag-us:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-1us:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-:x:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-AB:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-US:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-u:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flag-usx:]", + "eval.tests.test_flag_codes.test_invalid_flag_shape_stays_unchanged[:flags-us:]", + "eval.tests.test_flag_format_forms.test_attached_value_without_equals_is_undefined_flag", + "eval.tests.test_flag_format_forms.test_attached_value_without_equals_long_input", + "eval.tests.test_flag_format_forms.test_empty_equals_value_prints_nothing", + "eval.tests.test_flag_format_forms.test_leading_positional_arg_stops_flag_parsing", + "eval.tests.test_flag_format_forms.test_long_form_equals_flag", + "eval.tests.test_flag_format_forms.test_long_form_equals_flag_beer", + "eval.tests.test_flag_format_forms.test_long_form_equals_flag_country", + "eval.tests.test_flag_format_forms.test_single_lone_positional_arg_uses_default", + "eval.tests.test_known_codes.test_known_code_byte_output[:+1:-f09f918d20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:-1:-f09f918e20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:100:-f09f92af20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:1st_place_medal:-f09fa58720]", + "eval.tests.test_known_codes.test_known_code_byte_output[:8ball:-f09f8eb120]", + "eval.tests.test_known_codes.test_known_code_byte_output[:a:-f09f85b0efb88f20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:angry:-f09f98a020]", + "eval.tests.test_known_codes.test_known_code_byte_output[:b:-f09f85b1efb88f20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:beer:-f09f8dba20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:cat:-f09f90b120]", + "eval.tests.test_known_codes.test_known_code_byte_output[:coffee:-e2989520]", + "eval.tests.test_known_codes.test_known_code_byte_output[:computer:-f09f92bb20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:cry:-f09f98a220]", + "eval.tests.test_known_codes.test_known_code_byte_output[:dog:-f09f90b620]", + "eval.tests.test_known_codes.test_known_code_byte_output[:fire:-f09f94a520]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-br:-f09f87a7f09f87b720]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-cn:-f09f87a8f09f87b3]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-de:-f09f87a9f09f87aa]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-fr:-f09f87abf09f87b7]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-gb:-f09f87acf09f87a7]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-in:-f09f87aef09f87b320]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-it:-f09f87aef09f87b9]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-jp:-f09f87aff09f87b5]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-ng:-f09f87b3f09f87ac20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:flag-ru:-f09f87b7f09f87ba]", + "eval.tests.test_known_codes.test_known_code_byte_output[:gem:-f09f928e20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:heart:-e29da4efb88f20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:joy:-f09f988220]", + "eval.tests.test_known_codes.test_known_code_byte_output[:laughing:-f09f988620]", + "eval.tests.test_known_codes.test_known_code_byte_output[:mouse:-f09f90ad20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:phone:-e2988eefb88f20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:pizza:-f09f8d9520]", + "eval.tests.test_known_codes.test_known_code_byte_output[:poop:-f09f92a920]", + "eval.tests.test_known_codes.test_known_code_byte_output[:rocket:-f09f9a8020]", + "eval.tests.test_known_codes.test_known_code_byte_output[:smile:-f09f988420]", + "eval.tests.test_known_codes.test_known_code_byte_output[:star:-e2ad9020]", + "eval.tests.test_known_codes.test_known_code_byte_output[:sunglasses:-f09f988e20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:sushi:-f09f8da320]", + "eval.tests.test_known_codes.test_known_code_byte_output[:tea:-f09f8db520]", + "eval.tests.test_known_codes.test_known_code_byte_output[:thumbs_up:-f09f918d20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:thumbsdown:-f09f918e20]", + "eval.tests.test_known_codes.test_known_code_byte_output[:wink:-f09f988920]", + "eval.tests.test_known_codes.test_known_code_byte_output[:zzz:-f09f92a420]", + "eval.tests.test_literal_and_whitespace.test_leading_code_no_closing_colon_stays_literal", + "eval.tests.test_literal_and_whitespace.test_midstring_plain_colons_literal", + "eval.tests.test_literal_and_whitespace.test_no_closing_colon_stays_literal", + "eval.tests.test_literal_and_whitespace.test_percent_verbs_passthrough_literal", + "eval.tests.test_literal_and_whitespace.test_percent_with_exact_code", + "eval.tests.test_literal_and_whitespace.test_repeated_literal_colons", + "eval.tests.test_literal_and_whitespace.test_trailing_colon_only_stays_literal", + "eval.tests.test_literal_and_whitespace.test_unclosed_code_mid_sentence_literal", + "eval.tests.test_literal_and_whitespace.test_unicode_literals_preserved", + "eval.tests.test_literal_and_whitespace.test_whitespace_inside_code_aborts_token[: :smile:-: \\xf0\\x9f\\x98\\x84 ]", + "eval.tests.test_literal_and_whitespace.test_whitespace_inside_code_aborts_token[: smile:-: smile:]", + "eval.tests.test_literal_and_whitespace.test_whitespace_inside_code_aborts_token[:smil e:-:smil e:]", + "eval.tests.test_literal_and_whitespace.test_whitespace_inside_code_aborts_token[:smil\\n:-:smil\\n:]", + "eval.tests.test_literal_and_whitespace.test_whitespace_inside_code_aborts_token[:smil\\t:-:smil\\t:]", + "eval.tests.test_unicode_space_boundaries.test_combining_two_unicode_spaces_around_code", + "eval.tests.test_unicode_space_boundaries.test_flag_code_with_nbsp_suffix", + "eval.tests.test_unicode_space_boundaries.test_nbsp_between_two_codes", + "eval.tests.test_unicode_space_boundaries.test_nbsp_does_not_disable_later_code", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_after_code_preserved[IDEOSP-e38080]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_after_code_preserved[LINE_SEP-e280a8]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_after_code_preserved[NBSP-c2a0]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_after_code_preserved[THIN-e28089]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[CR-0d]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[EMQUAD-e28081]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[ENQ-e28080]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[FF-0c]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[HAIR-e2808a]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[IDEOSP-e38080]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[LINE_SEP-e280a8]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[NARROW-e280af]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[NBSP-c2a0]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[NEL-c285]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[PARA_SEP-e280a9]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[THIN-e28089]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[THREEPEREM-e28082]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_before_code_is_preserved[VT-0b]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[CR-0d]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[EMQUAD-e28081]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[ENQ-e28080]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[FF-0c]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[HAIR-e2808a]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[IDEOSP-e38080]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[LINE_SEP-e280a8]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[NARROW-e280af]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[NBSP-c2a0]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[NEL-c285]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[PARA_SEP-e280a9]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[THIN-e28089]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[THREEPEREM-e28082]", + "eval.tests.test_unicode_space_boundaries.test_unicode_space_inside_token_is_literal[VT-0b]", + "eval.tests.test_unknown_and_malformed.test_double_colon", + "eval.tests.test_unknown_and_malformed.test_embedded_unknown_token_kept", + "eval.tests.test_unknown_and_malformed.test_leading_colon_then_code_keeps_literal_colon", + "eval.tests.test_unknown_and_malformed.test_lone_colon", + "eval.tests.test_unknown_and_malformed.test_mid_string_registered_code_replaced", + "eval.tests.test_unknown_and_malformed.test_triple_colon_keeps_two_colons", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:aaaa:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:flag-1us:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:flag-:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:flag-AB:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:flag-usx:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:foobar:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:nope:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:unknown_x:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[:zzx:]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[a:b]", + "eval.tests.test_unknown_and_malformed.test_unknown_request_stays_byte_identical[x:y]", + "eval.tests.test_usage_golden.test_golden_equals_real_executable_usage_body", + "eval.tests.test_usage_golden.test_help_short_stderr_equals_usage_golden", + "eval.tests.test_usage_golden.test_help_stderr_equals_usage_golden", + "eval.tests.test_usage_golden.test_missing_argument_stderr_equals_usage_golden", + "eval.tests.test_usage_golden.test_undefined_flag_stderr_equals_usage_golden" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_emoji.test_aliases_normalize_to_same_emoji[:+1:]", + "eval.tests.test_emoji.test_aliases_normalize_to_same_emoji[:thumbs_up:]", + "eval.tests.test_emoji.test_aliases_normalize_to_same_emoji[:thumbsup:]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-ar:-ar]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-au:-au]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-br:-br]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-ca:-ca]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-id:-id]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-in:-in]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-ke:-ke]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-mx:-mx]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-ng:-ng]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-no:-no]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-nz:-nz]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-se:-se]", + "eval.tests.test_emoji.test_codemap_flag_shortcode_with_pad[:flag-ua:-ua]", + "eval.tests.test_emoji.test_colon_within_sentence_passthrough", + "eval.tests.test_emoji.test_consecutive_colons_keeps_leading_colon", + "eval.tests.test_emoji.test_consecutive_colons_two_emojis", + "eval.tests.test_emoji.test_default_flag_value", + "eval.tests.test_emoji.test_double_colon_passthrough", + "eval.tests.test_emoji.test_emoji_adjacent_to_punctuation", + "eval.tests.test_emoji.test_empty_string_prints_empty", + "eval.tests.test_emoji.test_flag_followed_by_word_no_space", + "eval.tests.test_emoji.test_flag_within_text", + "eval.tests.test_emoji.test_high_volume_repetition_scales_linearly", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:beer:-\\U0001f37a ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:coffee:-\\u2615 ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:heart:-\\u2764\\ufe0f ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:pizza:-\\U0001f355 ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:rocket:-\\U0001f680 ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:smile:-\\U0001f604 ]", + "eval.tests.test_emoji.test_known_shortcode_replaced_with_padding[:sushi:-\\U0001f363 ]", + "eval.tests.test_emoji.test_leading_and_trailing_consecutive_colons", + "eval.tests.test_emoji.test_lone_single_colon_passthrough", + "eval.tests.test_emoji.test_malformed_flag_inside_text", + "eval.tests.test_emoji.test_malformed_flag_passthrough[:flag-1b:]", + "eval.tests.test_emoji.test_malformed_flag_passthrough[:flag-:]", + "eval.tests.test_emoji.test_malformed_flag_passthrough[:flag-US:]", + "eval.tests.test_emoji.test_malformed_flag_passthrough[:flag-abc:]", + "eval.tests.test_emoji.test_malformed_flag_passthrough[:flag-u:]", + "eval.tests.test_emoji.test_many_distinct_shortcodes_ordered", + "eval.tests.test_emoji.test_mixed_flags_shortcodes_and_text", + "eval.tests.test_emoji.test_multiple_regex_flags", + "eval.tests.test_emoji.test_plain_text_passthrough[12345]", + "eval.tests.test_emoji.test_plain_text_passthrough[Hello World]", + "eval.tests.test_emoji.test_plain_text_passthrough[\\u03c0 \\u2248 3.14159]", + "eval.tests.test_emoji.test_plain_text_passthrough[no emoji here at all]", + "eval.tests.test_emoji.test_plain_text_passthrough[simple]", + "eval.tests.test_emoji.test_plain_text_passthrough[with spaces and\\nnewline]", + "eval.tests.test_emoji.test_postfixed_shortcode_no_delimiter_space", + "eval.tests.test_emoji.test_punctuation_then_direct_emoji", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-de:-de]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-es:-es]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-fr:-fr]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-gb:-gb]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-it:-it]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-jp:-jp]", + "eval.tests.test_emoji.test_regex_flag_shortcode_no_pad[:flag-us:-us]", + "eval.tests.test_emoji.test_repeated_same_shortcode", + "eval.tests.test_emoji.test_returns_clean_process_for_plain_text", + "eval.tests.test_emoji.test_shortcodes_within_sentence", + "eval.tests.test_emoji.test_single_letter_known_shortcode", + "eval.tests.test_emoji.test_space_separated_emoji_pair", + "eval.tests.test_emoji.test_stdout_has_no_trailing_newline", + "eval.tests.test_emoji.test_thumbsdown_emoji", + "eval.tests.test_emoji.test_triple_colon_passthrough", + "eval.tests.test_emoji.test_triple_space_separated_repetition", + "eval.tests.test_emoji.test_unknown_shortcode_inside_text", + "eval.tests.test_emoji.test_unknown_shortcode_passthrough[:foo:]", + "eval.tests.test_emoji.test_unknown_shortcode_passthrough[:no-such-emoji:]", + "eval.tests.test_emoji.test_unknown_shortcode_passthrough[:thisisnotanemojicode:]", + "eval.tests.test_emoji.test_unknown_shortcode_passthrough[:xyz:]", + "eval.tests.test_emoji.test_unknown_shortcode_passthrough[:zzzzz:]", + "eval.tests.test_emoji.test_whitespace_inside_token_passthrough[: beer:]", + "eval.tests.test_emoji.test_whitespace_inside_token_passthrough[: no-such :]", + "eval.tests.test_emoji.test_whitespace_inside_token_passthrough[:\\tbeer:]", + "eval.tests.test_emoji.test_whitespace_inside_token_passthrough[:beer :]", + "eval.tests.test_emoji.test_whitespace_inside_token_passthrough[:beer\\n:]" + ] + } + }, + "commit": "eb108489069ff2953e6bb4fe471784e664563644", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.9284470632091821, + "eval_clean_hashes": [ + "37139ff680d1a6b84c8a7a730718ba128a79033275bffa8d128b24a0a81991ae" + ], + "input_record": { + "commit": "eb108489069ff2953e6bb4fe471784e664563644", + "commits": 110, + "contributors": 12, + "difficulty": "easy", + "difficulty_code_lines": 8481, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 8481, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.9284470632091821, + "difficulty_test_code_lines": 286, + "full_name": "kyokomi/emoji", + "github_stars": 813, + "input_joern_zip": "go_joern/kyokomi__emoji.zip", + "joern_status": true, + "joern_time": 11.686923859873787, + "language": "go", + "pb_match": [ + { + "pb_fullname": "sclevine/yj", + "rank": 690, + "similarity": 0.48433029651641846 + }, + { + "pb_fullname": "antonmedv/walk", + "rank": 498, + "similarity": 0.48790836334228516 + }, + { + "pb_fullname": "mikefarah/yq", + "rank": 700, + "similarity": 0.5178471207618713 + }, + { + "pb_fullname": "rs/curlie", + "rank": 936, + "similarity": 0.4770911931991577 + }, + { + "pb_fullname": "alecthomas/chroma", + "rank": 243, + "similarity": 0.516211211681366 + }, + { + "pb_fullname": "mfridman/tparse", + "rank": 404, + "similarity": 0.5359339714050293 + }, + { + "pb_fullname": "jesseduffield/lazygit", + "rank": 660, + "similarity": 0.5042637586593628 + }, + { + "pb_fullname": "rs/jplot", + "rank": 252, + "similarity": 0.5358744859695435 + }, + { + "pb_fullname": "incu6us/goimports-reviser", + "rank": 715, + "similarity": 0.49180710315704346 + }, + { + "pb_fullname": "noborus/ov", + "rank": 966, + "similarity": 0.4818379282951355 + }, + { + "pb_fullname": "sheepla/pingu", + "rank": 464, + "similarity": 0.4993111789226532 + }, + { + "pb_fullname": "kyoh86/richgo", + "rank": 248, + "similarity": 0.5561937689781189 + }, + { + "pb_fullname": "eliukblau/pixterm", + "rank": 62, + "similarity": 0.5929492115974426 + }, + { + "pb_fullname": "TheZoraiz/ascii-image-converter", + "rank": 123, + "similarity": 0.5313803553581238 + }, + { + "pb_fullname": "cheat/cheat", + "rank": 949, + "similarity": 0.48248669505119324 + }, + { + "pb_fullname": "antonmedv/fx", + "rank": 377, + "similarity": 0.5015683770179749 + } + ], + "repo_age": 12.12, + "repo_path": "go/kyokomi__emoji", + "source": "commit:eb108489069ff2953e6bb4fe471784e664563644", + "status": "done", + "url": "https://github.com/kyokomi/emoji" + }, + "instance_id": "kyokomi__emoji.eb10848", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 3, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "coverage_path_attribution_failure" + }, + { + "actual_iterations": 1, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "coverage_path_attribution_failure" + } + ], + "repository": "kyokomi/emoji" +} diff --git a/kyokomi--emoji.eb10848/tests/test.sh b/kyokomi--emoji.eb10848/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kyokomi--emoji.eb10848/tests/workspace.tar.gz b/kyokomi--emoji.eb10848/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7e096e81b1c029c94ffad0dc379ecbe28ed4933e --- /dev/null +++ b/kyokomi--emoji.eb10848/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b7466ad9c4961f4818fa44127857a9120a6b452802a54369566fabfe0af472b +size 99645 diff --git a/kzampog--cilantro.cd473eb/environment/Dockerfile b/kzampog--cilantro.cd473eb/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..edce77c9eff98ecfdd18ea41d0dd516062fb88d9 --- /dev/null +++ b/kzampog--cilantro.cd473eb/environment/Dockerfile @@ -0,0 +1,55 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/kzampog--cilantro.cd473eb/environment/download.sh b/kzampog--cilantro.cd473eb/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..951eece721597c7583e81e64070f6b57ecd5b059 --- /dev/null +++ b/kzampog--cilantro.cd473eb/environment/download.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +# download.sh — ProgramGym download/prefetch stage for cilantro. +# +# This script is sourced (not executed) as: source /source_ro/download.sh +# It runs in a read-only repository mount WITH network access, and must NOT +# compile, link, test, or build anything. It only installs the system +# dependencies that the later OFFLINE build.sh needs, and exports the +# environment variables that build.sh relies on. +# +# Required by the cilantro build: the Eigen3 headers (version >= 3.3). Eigen +# is header-only, so installing libeigen3-dev is sufficient to compile both +# the cilantro library and the selected kd_tree example. + +# apt package lists are frequently stale on a fresh image; refresh them so the +# install below can resolve. Fail the download stage loudly if this cannot be +# done. +apt-get update + +# Install Eigen3 development headers together with the OpenMP runtime library +# (libgomp1) that the built executable depends on at runtime. Repeated sources +# of this script must be safe (idempotent): apt-get install on an already +# installed package simply reports it is up to date. +apt-get install -y libeigen3-dev libgomp1 + +# Export the include directory that the offline build.sh uses to find the +# Eigen3 headers installed above. The headers are always placed at this path +# by libeigen3-dev. +export EIGEN3_INCLUDE_DIR=/usr/include/eigen3 + +# Verify the installed Eigen headers are visible so build.sh is guaranteed to +# find them. This is a presence check only, not a build step. +if [ -f "${EIGEN3_INCLUDE_DIR}/Eigen/Core" ]; then + echo "download.sh: Eigen3 headers found at ${EIGEN3_INCLUDE_DIR}" +else + echo "download.sh: ERROR Eigen3 headers missing at ${EIGEN3_INCLUDE_DIR}" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kzampog--cilantro.cd473eb/environment/executable b/kzampog--cilantro.cd473eb/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..ce9ad14451699581be1553993541dab348f9fdcc --- /dev/null +++ b/kzampog--cilantro.cd473eb/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fe490dfc3e6e5a386d9ed219468ff801f9cfdec48270c2e4df6f3a3333b16e1 +size 2764176 diff --git a/kzampog--cilantro.cd473eb/environment/harbor_prepare_download_env.sh b/kzampog--cilantro.cd473eb/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kzampog--cilantro.cd473eb/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kzampog--cilantro.cd473eb/environment/workspace.tar.gz b/kzampog--cilantro.cd473eb/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..66bb513d2cf8e3cd7af95fbe2ee024a85cda377d --- /dev/null +++ b/kzampog--cilantro.cd473eb/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a833417a1a0190cecdd0fe928995419e43c948bbc97245b21d027afb4d6fffb2 +size 3792 diff --git a/kzampog--cilantro.cd473eb/instruction.md b/kzampog--cilantro.cd473eb/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/kzampog--cilantro.cd473eb/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/kzampog--cilantro.cd473eb/solution/solve.sh b/kzampog--cilantro.cd473eb/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/kzampog--cilantro.cd473eb/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/kzampog--cilantro.cd473eb/task.toml b/kzampog--cilantro.cd473eb/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..837a14dbc39da0acae508526f08d592f0ebf4042 --- /dev/null +++ b/kzampog--cilantro.cd473eb/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/kzampog--cilantro.cd473eb" +description = "Synthetic ProgramGym cleanroom reconstruction task for kzampog/cilantro" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "kzampog__cilantro.cd473eb" +repository = "kzampog/cilantro" +commit = "cd473ebcc5ac0f9e03d0b7f462bb742b1e987872" +language = "cpp" +difficulty = "medium" +difficulty_score = 3.4615225368715867 +test_branches = 6 +test_count = 586 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/kzampog--cilantro.cd473eb/tests/Dockerfile b/kzampog--cilantro.cd473eb/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..76cacca3a4006591209a34f93e00d4142b6fe407 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/Dockerfile @@ -0,0 +1,63 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_01.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4ae2a4a8ed8a0c32e557e0c17b280086e04a05ec --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cec162cd07895c587b74754fe92bd5a68ff9513a2a84ffbb7bbb7237762d6da3 +size 11936 diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_02.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..296c26273bd78412c9fae3ee63aaf7c62eec76ed --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:28d7472fee362cda7cc86987db612928bf7baef367de4e247e6141ba645afacd +size 19278 diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_03.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d7d76c220c8546559f8ae4e02c71a9f36bfce8b0 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:180e06b2b0cde4d322ddb90b47a7ed475594f04852e5fa75e4ac09d65d0deaf7 +size 10031 diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_04.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cad87c95957dd2c11536be06cfbafadbc3b309c1 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9814f81968f3516a87f1c26f0d88d2f9bb4a5d72b01dc49f653b111eaff5ac3 +size 16016 diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_05.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_05.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..bda68e449cab9ac3dcbee5b39e061d6f8879c8bc --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_05.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4364376f5ba2b0cc3f1bdf7e425211cd645163bed7878312caa6c18f16e7394e +size 1496969 diff --git a/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_06.tar.gz b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_06.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d78531b1fa6fb90187a3d568ebcb3765e7b328e4 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/blobs/tests/generated_module_06.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbfe2c0325ccceedca3c3fe928c11e7d564a97d3a4f26644468a4d9d540b919c +size 19578 diff --git a/kzampog--cilantro.cd473eb/tests/download.sh b/kzampog--cilantro.cd473eb/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..951eece721597c7583e81e64070f6b57ecd5b059 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/download.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +# download.sh — ProgramGym download/prefetch stage for cilantro. +# +# This script is sourced (not executed) as: source /source_ro/download.sh +# It runs in a read-only repository mount WITH network access, and must NOT +# compile, link, test, or build anything. It only installs the system +# dependencies that the later OFFLINE build.sh needs, and exports the +# environment variables that build.sh relies on. +# +# Required by the cilantro build: the Eigen3 headers (version >= 3.3). Eigen +# is header-only, so installing libeigen3-dev is sufficient to compile both +# the cilantro library and the selected kd_tree example. + +# apt package lists are frequently stale on a fresh image; refresh them so the +# install below can resolve. Fail the download stage loudly if this cannot be +# done. +apt-get update + +# Install Eigen3 development headers together with the OpenMP runtime library +# (libgomp1) that the built executable depends on at runtime. Repeated sources +# of this script must be safe (idempotent): apt-get install on an already +# installed package simply reports it is up to date. +apt-get install -y libeigen3-dev libgomp1 + +# Export the include directory that the offline build.sh uses to find the +# Eigen3 headers installed above. The headers are always placed at this path +# by libeigen3-dev. +export EIGEN3_INCLUDE_DIR=/usr/include/eigen3 + +# Verify the installed Eigen headers are visible so build.sh is guaranteed to +# find them. This is a presence check only, not a build step. +if [ -f "${EIGEN3_INCLUDE_DIR}/Eigen/Core" ]; then + echo "download.sh: Eigen3 headers found at ${EIGEN3_INCLUDE_DIR}" +else + echo "download.sh: ERROR Eigen3 headers missing at ${EIGEN3_INCLUDE_DIR}" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi diff --git a/kzampog--cilantro.cd473eb/tests/executable b/kzampog--cilantro.cd473eb/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..ce9ad14451699581be1553993541dab348f9fdcc --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fe490dfc3e6e5a386d9ed219468ff801f9cfdec48270c2e4df6f3a3333b16e1 +size 2764176 diff --git a/kzampog--cilantro.cd473eb/tests/harbor_prepare_download_env.sh b/kzampog--cilantro.cd473eb/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/kzampog--cilantro.cd473eb/tests/programgym_evaluator.py b/kzampog--cilantro.cd473eb/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/kzampog--cilantro.cd473eb/tests/programgym_task.json b/kzampog--cilantro.cd473eb/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..8e71db5ac0225ff4dbcc7aee68c9896f3d1e7d9d --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/programgym_task.json @@ -0,0 +1,879 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_kd_tree_driver_behavior.test_alternate_executable_name_is_ignored", + "eval.tests.test_kd_tree_driver_behavior.test_labels_present_on_the_golden_run", + "eval.tests.test_kd_tree_driver_behavior.test_output_survives_near_empty_environment", + "eval.tests.test_kd_tree_oracle.test_all_reported_neighbors_inside_radius", + "eval.tests.test_kd_tree_oracle.test_distances_are_non_negative_finite", + "eval.tests.test_kd_tree_oracle.test_distances_strictly_increasing", + "eval.tests.test_kd_tree_oracle.test_empty_stderr", + "eval.tests.test_kd_tree_oracle.test_geometry_confirms_farther_corners_excluded", + "eval.tests.test_kd_tree_oracle.test_index_distance_pairs_are_correct_neighbors", + "eval.tests.test_kd_tree_oracle.test_indices_are_valid_tree_members", + "eval.tests.test_kd_tree_oracle.test_neighbor_indices_are_distinct", + "eval.tests.test_kd_tree_oracle.test_no_crash_arg_mix", + "eval.tests.test_kd_tree_oracle.test_prints_exactly_k2_neighbors", + "eval.tests.test_kd_tree_oracle.test_reported_distances_are_squared_l2", + "eval.tests.test_kd_tree_oracle.test_results_sorted_ascending_by_distance", + "eval.tests.test_kd_tree_output.test_deterministic_across_repeats", + "eval.tests.test_kd_tree_output.test_exit_zero_even_with_flags", + "eval.tests.test_kd_tree_output.test_exits_successfully", + "eval.tests.test_kd_tree_output.test_output_independent_of_closed_stdin", + "eval.tests.test_kd_tree_output.test_output_independent_of_explicit_argv", + "eval.tests.test_kd_tree_output.test_output_independent_of_stdin", + "eval.tests.test_kd_tree_output.test_output_stable_under_openmp_thread_counts[16]", + "eval.tests.test_kd_tree_output.test_output_stable_under_openmp_thread_counts[1]", + "eval.tests.test_kd_tree_output.test_output_stable_under_openmp_thread_counts[2]", + "eval.tests.test_kd_tree_output.test_output_stable_under_openmp_thread_counts[4]", + "eval.tests.test_kd_tree_output.test_stdout_has_exactly_two_lines", + "eval.tests.test_kd_tree_output.test_stdout_matches_golden_exactly", + "eval.tests.test_kd_tree_process_lifecycle.test_clean_exit_is_not_signal_killed", + "eval.tests.test_kd_tree_process_lifecycle.test_closed_stderr_still_yields_golden_stdout", + "eval.tests.test_kd_tree_process_lifecycle.test_closed_stdout_reliably_sigpipes", + "eval.tests.test_kd_tree_process_lifecycle.test_dev_null_stdin_still_yields_golden_stdout", + "eval.tests.test_kd_tree_process_lifecycle.test_open_stdout_positive_control_yields_golden", + "eval.tests.test_kd_tree_process_lifecycle.test_process_completes_promptly_without_hanging", + "eval.tests.test_kd_tree_process_lifecycle.test_sigpipe_confirmed_by_wait_timeout_zero", + "eval.tests.test_kd_tree_process_lifecycle.test_sigpipe_termination_when_stdout_pipe_closed", + "eval.tests.test_kd_tree_robustness.test_float_formatting_is_literal_not_locale", + "eval.tests.test_kd_tree_robustness.test_golden_file_is_loaded_and_matches", + "eval.tests.test_kd_tree_robustness.test_large_argv_does_not_crash_or_alter_output", + "eval.tests.test_kd_tree_robustness.test_line_encoding_is_utf8_lf", + "eval.tests.test_kd_tree_robustness.test_no_files_created_in_scratch_dir", + "eval.tests.test_kd_tree_robustness.test_output_stable_under_combined_argv_env_cwd_stress", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_cwd", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_environment_variables[HOME]", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_environment_variables[TEMP]", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_environment_variables[TMPDIR]", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_environment_variables[TMP]", + "eval.tests.test_kd_tree_robustness.test_result_independent_of_environment_variables[USER]", + "eval.tests.test_kd_tree_robustness.test_standard_streams_are_separate", + "eval.tests.test_kd_tree_robustness.test_stdout_terminated_by_single_newline" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_golden_and_output_path_facets.test_golden_file_and_inline_canonical_agree", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_golden_and_output_path_facets.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_and_output_path_facets.test_stdout_is_writable_to_branch_local_golden_format", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_golden_and_output_path_facets.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_golden_and_output_path_facets.test_stdout_matches_golden_file_normalized", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_golden_and_output_path_facets.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_argument_handling.test_argv_with_python_flag_like_tokens", + "eval.tests.test_argument_handling.test_empty_string_argument", + "eval.tests.test_argument_handling.test_help_flag", + "eval.tests.test_argument_handling.test_leading_dash_argument", + "eval.tests.test_argument_handling.test_long_help_flag", + "eval.tests.test_argument_handling.test_malformed_argument_tokens", + "eval.tests.test_argument_handling.test_many_short_arguments", + "eval.tests.test_argument_handling.test_mixed_flags_and_values", + "eval.tests.test_argument_handling.test_multibyte_utf8_argument", + "eval.tests.test_argument_handling.test_multiple_arguments", + "eval.tests.test_argument_handling.test_no_arguments", + "eval.tests.test_argument_handling.test_numeric_looking_argument", + "eval.tests.test_argument_handling.test_repeated_flag_argument", + "eval.tests.test_argument_handling.test_single_positional_argument", + "eval.tests.test_argument_handling.test_version_flag", + "eval.tests.test_argument_handling.test_very_long_argument", + "eval.tests.test_concurrency_determinism.test_concurrent_invocations_are_all_canonical", + "eval.tests.test_concurrency_determinism.test_concurrent_invocations_share_no_stdout_residue", + "eval.tests.test_cwd_shape_robustness.test_cwd_with_spaces", + "eval.tests.test_cwd_shape_robustness.test_cwd_with_unicode_name", + "eval.tests.test_cwd_shape_robustness.test_deep_nested_cwd", + "eval.tests.test_cwd_shape_robustness.test_executable_does_not_create_hidden_files_in_cwd", + "eval.tests.test_cwd_shape_robustness.test_long_cwd_path", + "eval.tests.test_determinism.test_deterministic_across_arg_repetitions", + "eval.tests.test_determinism.test_interleaved_runs_do_not_perturb_each_other", + "eval.tests.test_determinism.test_many_run_hashes_are_equal", + "eval.tests.test_determinism.test_repeated_runs_byte_identical", + "eval.tests.test_determinism.test_stdout_matches_reference_bytes", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv0]", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv1]", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv2]", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv3]", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv4]", + "eval.tests.test_exit_and_streams.test_exit_status_zero[argv5]", + "eval.tests.test_exit_and_streams.test_no_error_keywords_anywhere", + "eval.tests.test_exit_and_streams.test_returns_success_despite_large_stdin", + "eval.tests.test_exit_and_streams.test_returns_success_when_stdin_closed", + "eval.tests.test_exit_and_streams.test_stderr_is_empty", + "eval.tests.test_exit_and_streams.test_stdout_and_stderr_are_separate_streams", + "eval.tests.test_exit_and_streams.test_stdout_is_not_empty", + "eval.tests.test_golden_and_output_path_facets.test_append_mode_output_accumulates_across_run_lifetimes", + "eval.tests.test_golden_and_output_path_facets.test_both_streams_share_one_append_mode_file", + "eval.tests.test_golden_and_output_path_facets.test_golden_file_and_inline_canonical_agree", + "eval.tests.test_golden_and_output_path_facets.test_no_output_files_written_when_stdout_is_dev_null_and_cwd_empty", + "eval.tests.test_golden_and_output_path_facets.test_output_file_behind_symlink_receives_canonical", + "eval.tests.test_golden_and_output_path_facets.test_output_file_in_spaced_unicode_dir_receives_canonical", + "eval.tests.test_golden_and_output_path_facets.test_stdout_is_writable_to_branch_local_golden_format", + "eval.tests.test_golden_and_output_path_facets.test_stdout_matches_golden_file_normalized", + "eval.tests.test_isolation_and_env.test_completes_well_within_time_budget", + "eval.tests.test_isolation_and_env.test_missing_cwd_fails_while_valid_cwd_gives_canonical_report", + "eval.tests.test_isolation_and_env.test_no_files_written_into_empty_cwd", + "eval.tests.test_isolation_and_env.test_no_output_file_in_nested_cwd", + "eval.tests.test_isolation_and_env.test_numeric_env_overrides_do_not_perturb", + "eval.tests.test_isolation_and_env.test_oom_threads_env_does_not_change_output", + "eval.tests.test_isolation_and_env.test_readonly_cwd_does_not_block_run", + "eval.tests.test_knn_semantics.test_both_neighbour_values_inside_search_radius", + "eval.tests.test_knn_semantics.test_cardinality_is_two", + "eval.tests.test_knn_semantics.test_cube_has_eight_official_corners", + "eval.tests.test_knn_semantics.test_distances_alongside_indices_in_same_position", + "eval.tests.test_knn_semantics.test_indices_ordered_increasing", + "eval.tests.test_knn_semantics.test_no_index_equals_query_point_itself", + "eval.tests.test_knn_semantics.test_output_is_monotonic_in_distance", + "eval.tests.test_knn_semantics.test_query_matches_expected_squared_distances", + "eval.tests.test_knn_semantics.test_reported_distances_are_018_and_038", + "eval.tests.test_knn_semantics.test_reported_indices_are_0_and_3", + "eval.tests.test_knn_semantics.test_reported_indices_are_inside_radius", + "eval.tests.test_knn_semantics.test_squared_distances_match_euclidean", + "eval.tests.test_locale_robustness.test_report_invariant_under_gc_string_chrony_envs", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[C.UTF-8]", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[C]", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[POSIX]", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[de_DE.UTF-8]", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[en_US.UTF-8]", + "eval.tests.test_locale_robustness.test_report_invariant_under_locale[fr_FR.UTF-8]", + "eval.tests.test_locale_robustness.test_report_invariant_under_timezone", + "eval.tests.test_stdout_contract.test_line_order_is_indices_then_distances", + "eval.tests.test_stdout_contract.test_max_line_length_is_bounded", + "eval.tests.test_stdout_contract.test_no_carriage_returns_in_stdout", + "eval.tests.test_stdout_contract.test_stdout_ends_after_distances_line", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_lines[dash-dash-help]", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_lines[dash-dash-version]", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_lines[dash-h]", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_lines[no-args]", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_lines[positional]", + "eval.tests.test_stdout_contract.test_stdout_is_ascii_only", + "eval.tests.test_stdout_contract.test_stdout_line1_exact_text", + "eval.tests.test_stdout_contract.test_stdout_line2_exact_text", + "eval.tests.test_stdout_contract.test_trailing_space_after_last_distance", + "eval.tests.test_stream_and_path_robustness.test_both_streams_redirected_yield_expected_files", + "eval.tests.test_stream_and_path_robustness.test_existing_data_file_argument_is_ignored_and_untouched", + "eval.tests.test_stream_and_path_robustness.test_process_terminates_normally_not_by_signal", + "eval.tests.test_stream_and_path_robustness.test_redirect_truncates_preexisting_output_file", + "eval.tests.test_stream_and_path_robustness.test_shell_driven_invocation_yields_same_report", + "eval.tests.test_stream_and_path_robustness.test_stderr_redirected_to_file_stays_empty", + "eval.tests.test_stream_and_path_robustness.test_stdout_redirected_to_file_is_exact_canonical", + "eval.tests.test_stream_and_path_robustness.test_symlinked_executable_alias_yields_same_report", + "eval.tests.test_stream_and_path_robustness.test_very_large_argument_list_is_still_ignored", + "eval.tests.test_stream_topologies_and_shared_fd.test_append_mode_file_preserves_seed_and_appends_canonical", + "eval.tests.test_stream_topologies_and_shared_fd.test_both_streams_share_single_file_object", + "eval.tests.test_stream_topologies_and_shared_fd.test_concurrent_appends_to_shared_file_are_whole_and_in_order", + "eval.tests.test_stream_topologies_and_shared_fd.test_pipeline_through_cat_preserves_exact_bytes", + "eval.tests.test_stream_topologies_and_shared_fd.test_stderr_to_dev_null_while_stdout_is_canonical", + "eval.tests.test_stream_topologies_and_shared_fd.test_stdin_from_real_file_is_ignored", + "eval.tests.test_stream_topologies_and_shared_fd.test_stdout_to_dev_null_leaves_exit_zero_and_no_stderr", + "eval.tests.test_stream_topologies_and_shared_fd.test_stdout_to_named_pipe_fifo_yields_canonical", + "eval.tests.test_stream_topologies_and_shared_fd.test_terminal_environment_variables_do_not_alter_report" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_observable.test_arbitrary_environment_variables_do_not_change_output", + "eval.tests.test_observable.test_binary_is_not_a_streaming_stdio_filter", + "eval.tests.test_observable.test_branch_root_executable_is_present_execvable_and_elf", + "eval.tests.test_observable.test_cwd_independent_output", + "eval.tests.test_observable.test_distance_tokens_match_formatted_decimals", + "eval.tests.test_observable.test_distance_tokens_parse_to_bounded_nonnegative_floats", + "eval.tests.test_observable.test_empty_stderr_on_success", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset0]", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset1]", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset2]", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset3]", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset4]", + "eval.tests.test_observable.test_given_no_valid_self_configuration_the_output_is_stable[argset5]", + "eval.tests.test_observable.test_index_tokens_are_exactly_two_in_expected_order", + "eval.tests.test_observable.test_many_command_line_arguments_are_all_ignored[1]", + "eval.tests.test_observable.test_many_command_line_arguments_are_all_ignored[40]", + "eval.tests.test_observable.test_many_command_line_arguments_are_all_ignored[8]", + "eval.tests.test_observable.test_neighbor_indices_are_present_and_sorted", + "eval.tests.test_observable.test_output_can_be_recovered_from_a_redirected_file", + "eval.tests.test_observable.test_output_is_byte_stable_across_runs[0]", + "eval.tests.test_observable.test_output_is_byte_stable_across_runs[1]", + "eval.tests.test_observable.test_output_is_byte_stable_across_runs[2]", + "eval.tests.test_observable.test_output_is_deterministic_across_many_repetitions", + "eval.tests.test_observable.test_output_roundtrips_through_a_pipe_unchanged", + "eval.tests.test_observable.test_output_unaffected_by_populated_working_directory", + "eval.tests.test_observable.test_reported_distances_are_squared_l2_from_query", + "eval.tests.test_observable.test_reported_indices_are_the_two_globally_nearest_verts", + "eval.tests.test_observable.test_stdin_is_ignored_and_output_unchanged", + "eval.tests.test_observable.test_stdout_contains_only_printable_ascii", + "eval.tests.test_observable.test_stdout_is_byte_exact_including_trailing_spaces", + "eval.tests.test_observable.test_stdout_is_two_lines_each_with_exact_token_count", + "eval.tests.test_observable.test_stdout_label_literals_are_exact", + "eval.tests.test_observable.test_stdout_matches_golden_baseline", + "eval.tests.test_search_semantics.test_all_inside_verts_have_distance_no_larger_than_radius", + "eval.tests.test_search_semantics.test_distance_value_0_18_corresponds_to_vertex_zero", + "eval.tests.test_search_semantics.test_query_is_not_a_cube_vertex", + "eval.tests.test_search_semantics.test_radius_includes_more_verts_but_k_selects_the_two_nearest", + "eval.tests.test_search_semantics.test_radius_is_tight_relative_to_two_reported_vertices", + "eval.tests.test_search_semantics.test_reported_distances_are_the_two_smallest_sq_distances", + "eval.tests.test_search_semantics.test_reported_indices_line_up_with_reported_distances", + "eval.tests.test_search_semantics.test_reported_neighbours_are_all_distinct_vertices", + "eval.tests.test_search_semantics.test_reported_set_is_exactly_the_nearest_k_inside_radius", + "eval.tests.test_search_semantics.test_stdout_has_exactly_two_nonempty_lines", + "eval.tests.test_streaming.test_closing_stdout_before_delivery_sigpipes_deterministically", + "eval.tests.test_streaming.test_first_report_line_is_streamed_before_process_exit", + "eval.tests.test_streaming.test_report_is_two_independently_readable_frames" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_regular_file_output.test_multiple_regular_files_from_parallel_processes_are_identical", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_regular_file_output.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_regular_file_output.test_output_file_has_exact_golden_length_and_terminator", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_regular_file_output.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_regular_file_output.test_stdout_and_stderr_merged_into_one_file_matches_golden", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_regular_file_output.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_regular_file_output.test_stdout_redirected_to_regular_file_matches_golden", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_regular_file_output.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_regular_file_output.test_stdout_through_named_fifo_matches_golden", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_regular_file_output.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_argument_handling.test_argument_ordering_invariance", + "eval.tests.test_argument_handling.test_argument_with_equals", + "eval.tests.test_argument_handling.test_double_dash_separator", + "eval.tests.test_argument_handling.test_duplicate_arguments", + "eval.tests.test_argument_handling.test_empty_string_argument", + "eval.tests.test_argument_handling.test_flag_with_value", + "eval.tests.test_argument_handling.test_help_flag", + "eval.tests.test_argument_handling.test_long_single_argument_boundary", + "eval.tests.test_argument_handling.test_many_positional_arguments", + "eval.tests.test_argument_handling.test_no_arguments", + "eval.tests.test_argument_handling.test_non_utf8_arguments", + "eval.tests.test_argument_handling.test_short_help_flag", + "eval.tests.test_argument_handling.test_single_positional_argument", + "eval.tests.test_argument_handling.test_two_positional_arguments", + "eval.tests.test_argument_handling.test_unrecognized_flag", + "eval.tests.test_argument_handling.test_version_flag", + "eval.tests.test_determinism_and_robustness.test_clean_environment_golden", + "eval.tests.test_determinism_and_robustness.test_concurrent_invocations_by_threads", + "eval.tests.test_determinism_and_robustness.test_does_not_create_or_modify_files", + "eval.tests.test_determinism_and_robustness.test_empty_environment_does_not_break_launch", + "eval.tests.test_determinism_and_robustness.test_locale_variation_no_effect", + "eval.tests.test_determinism_and_robustness.test_no_output_files_in_branch", + "eval.tests.test_determinism_and_robustness.test_run_is_repeatable_two_runs", + "eval.tests.test_determinism_and_robustness.test_sequential_runs_identical", + "eval.tests.test_executable_structure.test_elf_class_is_64_bit", + "eval.tests.test_executable_structure.test_elf_data_is_little_endian", + "eval.tests.test_executable_structure.test_elf_magic_bytes", + "eval.tests.test_executable_structure.test_elf_type_is_executable", + "eval.tests.test_executable_structure.test_executable_is_a_runnable_program", + "eval.tests.test_executable_structure.test_executable_is_non_empty", + "eval.tests.test_executable_structure.test_executable_produces_golden_stdout", + "eval.tests.test_executable_structure.test_runs_from_arbitrary_cwd", + "eval.tests.test_executable_structure.test_runs_from_scratch_dir", + "eval.tests.test_executable_structure.test_terminates_within_timeout", + "eval.tests.test_output_semantics.test_distance_tokens_have_exact_string_formatting", + "eval.tests.test_output_semantics.test_each_reported_distance_positive_and_finite", + "eval.tests.test_output_semantics.test_first_neighbour_is_corner_origin", + "eval.tests.test_output_semantics.test_report_uses_squared_distances_instead_of_euclidean", + "eval.tests.test_output_semantics.test_reported_distances_are_squared_euclidean", + "eval.tests.test_output_semantics.test_reported_distances_are_strictly_increasing", + "eval.tests.test_output_semantics.test_reported_indices_are_in_dataset_range", + "eval.tests.test_output_semantics.test_reported_result_matches_smallest_two_inradius_distances", + "eval.tests.test_output_semantics.test_second_neighbour_is_z_corner", + "eval.tests.test_process_concurrency.test_concurrent_processes_agree_with_each_other", + "eval.tests.test_process_concurrency.test_independent_processes_emit_identical_golden", + "eval.tests.test_process_concurrency.test_processes_do_not_share_state", + "eval.tests.test_process_concurrency.test_worker_count_does_not_change_output", + "eval.tests.test_regular_file_output.test_multiple_regular_files_from_parallel_processes_are_identical", + "eval.tests.test_regular_file_output.test_output_file_has_exact_golden_length_and_terminator", + "eval.tests.test_regular_file_output.test_stdout_and_stderr_merged_into_one_file_matches_golden", + "eval.tests.test_regular_file_output.test_stdout_redirected_to_regular_file_matches_golden", + "eval.tests.test_regular_file_output.test_stdout_through_named_fifo_matches_golden", + "eval.tests.test_regular_file_output.test_stdout_to_devnull_stderr_to_file_stays_empty", + "eval.tests.test_stdin_handling.test_binary_stdin", + "eval.tests.test_stdin_handling.test_empty_stdin", + "eval.tests.test_stdin_handling.test_large_stdin_boundary", + "eval.tests.test_stdin_handling.test_mls_style_stdin", + "eval.tests.test_stdin_handling.test_newline_only_stdin", + "eval.tests.test_stdin_handling.test_non_utf8_stdin", + "eval.tests.test_stdin_handling.test_stdin_closed_early", + "eval.tests.test_stdin_handling.test_stdin_not_read_confirmed_by_pipe_full", + "eval.tests.test_stdin_handling.test_stdin_unset_is_empty", + "eval.tests.test_stdin_handling.test_text_stdin", + "eval.tests.test_stdout_behavior.test_distances_line_format_exact_regex", + "eval.tests.test_stdout_behavior.test_distances_line_has_trailing_space_before_newline", + "eval.tests.test_stdout_behavior.test_distances_tokens_are_two_floats", + "eval.tests.test_stdout_behavior.test_exit_status_is_zero", + "eval.tests.test_stdout_behavior.test_first_line_is_indices_header", + "eval.tests.test_stdout_behavior.test_golden_usage_is_exact", + "eval.tests.test_stdout_behavior.test_indices_and_distances_counts_match", + "eval.tests.test_stdout_behavior.test_indices_are_valid_dataset_ids", + "eval.tests.test_stdout_behavior.test_indices_line_format_exact_regex", + "eval.tests.test_stdout_behavior.test_indices_line_has_trailing_space_before_newline", + "eval.tests.test_stdout_behavior.test_indices_line_precedes_distances_line", + "eval.tests.test_stdout_behavior.test_indices_tokens_are_two_integers", + "eval.tests.test_stdout_behavior.test_output_uses_unix_newlines", + "eval.tests.test_stdout_behavior.test_second_line_is_distances_header", + "eval.tests.test_stdout_behavior.test_stderr_is_empty", + "eval.tests.test_stdout_behavior.test_stdout_has_exactly_two_lines", + "eval.tests.test_stdout_behavior.test_stdout_is_plain_ascii", + "eval.tests.test_stdout_behavior.test_stdout_matches_golden_as_text", + "eval.tests.test_stdout_behavior.test_stdout_matches_golden_bytes", + "eval.tests.test_stream_path_robustness.test_closed_stdout_pipe_is_terminated_by_sigpipe", + "eval.tests.test_stream_path_robustness.test_pty_output_uses_carriage_return_translation", + "eval.tests.test_stream_path_robustness.test_stdout_and_stderr_split_pipes_drained_together", + "eval.tests.test_stream_path_robustness.test_stdout_pipe_fills_then_drains_without_hanging", + "eval.tests.test_stream_path_robustness.test_stdout_reassembled_from_three_byte_chunks", + "eval.tests.test_stream_path_robustness.test_stdout_via_pseudoterminal_matches_content_after_onlcr" + ] + }, + "generated_module_05": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_additional_public_api.test_2d_affine_combined_metric_estimation_succeeds", + "eval.tests.test_additional_public_api.test_2d_combined_metric_empty_terms_fails", + "eval.tests.test_additional_public_api.test_2d_combined_metric_estimation_recovers_rotation", + "eval.tests.test_additional_public_api.test_2d_combined_metric_estimation_succeeds", + "eval.tests.test_additional_public_api.test_2d_symmetric_metric_estimation_recovers_rotation", + "eval.tests.test_additional_public_api.test_2d_symmetric_metric_estimation_succeeds", + "eval.tests.test_additional_public_api.test_3d_combined_metric_rejects_normal_size_mismatch", + "eval.tests.test_additional_public_api.test_combined_metric_wrapper_aligns_cloud", + "eval.tests.test_additional_public_api.test_combined_metric_wrapper_converges", + "eval.tests.test_additional_public_api.test_combined_metric_wrapper_weight_setters_round_trip", + "eval.tests.test_additional_public_api.test_hyperplane_direct_full_cloud_model_normal", + "eval.tests.test_additional_public_api.test_hyperplane_direct_full_cloud_model_offset", + "eval.tests.test_additional_public_api.test_hyperplane_direct_model_residuals_all_within_threshold", + "eval.tests.test_additional_public_api.test_hyperplane_direct_model_residuals_one_per_point", + "eval.tests.test_additional_public_api.test_hyperplane_estimator_reports_point_count", + "eval.tests.test_additional_public_api.test_hyperplane_explicit_sample_model_normal", + "eval.tests.test_additional_public_api.test_icp_get_transform_out_arg_recovers_inverse", + "eval.tests.test_additional_public_api.test_icp_last_update_norm_tiny_after_convergence", + "eval.tests.test_additional_public_api.test_kdtree_both_direction_enum_and_search", + "eval.tests.test_additional_public_api.test_kdtree_both_direction_transform_search", + "eval.tests.test_additional_public_api.test_kdtree_evaluator_accessor_returns_injected_evaluator", + "eval.tests.test_additional_public_api.test_kdtree_first_to_second_transform_search", + "eval.tests.test_additional_public_api.test_line_direct_model_normal_direction", + "eval.tests.test_additional_public_api.test_line_direct_model_offset", + "eval.tests.test_additional_public_api.test_line_direct_model_residuals_all_within_threshold", + "eval.tests.test_additional_public_api.test_line_direct_model_residuals_one_per_point", + "eval.tests.test_additional_public_api.test_line_estimator_reports_point_count", + "eval.tests.test_additional_public_api.test_point_normal_features_dimension", + "eval.tests.test_additional_public_api.test_point_normal_features_transform_moves_point_components", + "eval.tests.test_additional_public_api.test_ransac_max_inlier_residual_round_trip", + "eval.tests.test_additional_public_api.test_transform_ransac_correspondence_ctor_point_count", + "eval.tests.test_additional_public_api.test_transform_ransac_correspondence_model_all_pairs_tight", + "eval.tests.test_additional_public_api.test_transform_ransac_correspondence_model_recovers_translation", + "eval.tests.test_additional_public_api.test_transform_ransac_correspondence_model_residuals_one_per_point", + "eval.tests.test_additional_public_api.test_transform_ransac_explicit_sample_model_recovers_motion", + "eval.tests.test_additional_public_api.test_transform_ransac_index_vector_ctor_point_count", + "eval.tests.test_base_getters_and_extra_overloads.test_affine_combined_metric_estimation_recovers_scale", + "eval.tests.test_base_getters_and_extra_overloads.test_affine_combined_metric_estimation_recovers_translation", + "eval.tests.test_base_getters_and_extra_overloads.test_affine_combined_metric_estimation_succeeds", + "eval.tests.test_base_getters_and_extra_overloads.test_combiner_same_engine_fast_path_finds_shared_correspondences", + "eval.tests.test_base_getters_and_extra_overloads.test_combiner_same_engine_getters_return_same_object", + "eval.tests.test_base_getters_and_extra_overloads.test_combiner_two_engines_transform_search_runs_both", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_convergence_tolerance_getter_reflects_setter", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_correspondence_search_engine_accessor_reconfigures_radius", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_initial_transform_getter_reflects_set_translation", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_max_iterations_getter_reflects_setter", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_per_point_residuals_match_source_size", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_two_arg_estimate_overload_converges", + "eval.tests.test_base_getters_and_extra_overloads.test_icp_with_initial_transform_still_converges", + "eval.tests.test_base_getters_and_extra_overloads.test_kdtree_distinct_eval_features_transform_search", + "eval.tests.test_base_getters_and_extra_overloads.test_kdtree_injected_tree_retrievable_via_getter", + "eval.tests.test_base_getters_and_extra_overloads.test_kdtree_injected_trees_search_correctly", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_default_target_inlier_count_is_half_the_points", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_max_iterations_round_trip", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_model_inliers_all_points_when_coplanar", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_model_residuals_one_per_point", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_no_reestimation_preserves_plane_normal", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_no_reestimation_still_classifies_all_coplanar_inliers", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_reestimate_loose_then_tight_inliers", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_reestimation_disabled_is_reported_by_getter", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_residuals_within_threshold", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_set_sample_size_reflected_by_getter", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_set_target_inlier_count_round_trip", + "eval.tests.test_base_getters_and_extra_overloads.test_ransac_target_above_point_count_is_clamped_and_achievable", + "eval.tests.test_base_getters_and_extra_overloads.test_symmetric_metric_estimation_identity_link", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_adaptor_base_engine_identity_preserved", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_adaptor_point_to_plane_view_populated", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_adaptor_point_to_point_view_populated", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_adaptor_transform_searched_route", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_bi_pairs_are_aligned", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_bi_reciprocal_is_a_subset", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_bi_returns_union", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_empty_reference_tree", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_finds_all_pairs", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_first_pair_indices", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_max_distance_filters_all", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_pairs_are_aligned", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_reference_first_roles", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_kdtree_utils_uni_residuals_below_max_distance", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_point_normal_adaptor_feature_dimension", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_point_normal_search_finds_all_pairs", + "eval.tests.test_combined_metric_and_kdtree_utilities.test_point_normal_search_pairs_are_aligned", + "eval.tests.test_correspondence_search.test_kdtree_bidirectional_union_is_at_least_each_single_direction", + "eval.tests.test_correspondence_search.test_kdtree_default_max_distance_is_tiny", + "eval.tests.test_correspondence_search.test_kdtree_empty_reference_set_yields_no_correspondences", + "eval.tests.test_correspondence_search.test_kdtree_empty_source_set_yields_no_correspondences", + "eval.tests.test_correspondence_search.test_kdtree_first_to_second_direction_returns_correspondences", + "eval.tests.test_correspondence_search.test_kdtree_first_to_second_first_pair_indexing", + "eval.tests.test_correspondence_search.test_kdtree_getters_reflect_setters", + "eval.tests.test_correspondence_search.test_kdtree_inlier_fraction_keeps_proportional_matches", + "eval.tests.test_correspondence_search.test_kdtree_large_transform_removes_in_radius_matches", + "eval.tests.test_correspondence_search.test_kdtree_max_distance_filters_correspondences", + "eval.tests.test_correspondence_search.test_kdtree_med_and_large_thresholds_saturate", + "eval.tests.test_correspondence_search.test_kdtree_one_to_one_collapses_duplicate_destinations", + "eval.tests.test_correspondence_search.test_kdtree_reciprocal_is_a_subset_of_bidirectional", + "eval.tests.test_correspondence_search.test_oracle_default_threshold_rejects_positive_values", + "eval.tests.test_correspondence_search.test_oracle_inlier_fraction_halves_results", + "eval.tests.test_correspondence_search.test_oracle_max_distance_keeps_values_below_threshold", + "eval.tests.test_correspondence_search.test_oracle_zero_threshold_keeps_nothing", + "eval.tests.test_correspondence_search.test_projective_kinect_intrinsics_defaults", + "eval.tests.test_correspondence_search.test_projective_search_finds_matching_projected_points", + "eval.tests.test_correspondence_search.test_projective_tiny_threshold_keeps_only_coincident_pairs", + "eval.tests.test_extended_registration.test_2d_affine_icp_converges_to_near_zero_residual", + "eval.tests.test_extended_registration.test_2d_affine_icp_recovers_scale", + "eval.tests.test_extended_registration.test_2d_affine_icp_recovers_translation", + "eval.tests.test_extended_registration.test_2d_affine_icp_reports_convergence", + "eval.tests.test_extended_registration.test_2d_rigid_icp_converges_to_near_zero_residual", + "eval.tests.test_extended_registration.test_2d_rigid_icp_performs_iterations_and_converges", + "eval.tests.test_extended_registration.test_2d_rigid_icp_recovers_rotation", + "eval.tests.test_extended_registration.test_2d_rigid_icp_recovers_translation", + "eval.tests.test_extended_registration.test_2d_rigid_icp_reduces_initial_misalignment", + "eval.tests.test_extended_registration.test_2d_wrapper_icp_performs_iterations", + "eval.tests.test_extended_registration.test_2d_wrapper_icp_reduces_residual", + "eval.tests.test_extended_registration.test_3d_wrapper_icp_converges", + "eval.tests.test_extended_registration.test_combined_metric_weights_round_trip", + "eval.tests.test_extended_registration.test_plane_ransac_two_groups_target_not_achieved", + "eval.tests.test_extended_registration.test_point_to_plane_icp_lands_source_on_plane", + "eval.tests.test_extended_registration.test_rigid_ransac_best_model_still_recovers_rotation", + "eval.tests.test_extended_registration.test_rigid_ransac_outliers_keep_target_unachieved", + "eval.tests.test_golden_executable.test_exact_stdout_matches_golden_file", + "eval.tests.test_golden_executable.test_first_line_reports_neighbor_indices_0_and_3", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[--help]", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[-1]", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[-h]", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[-v]", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[0]", + "eval.tests.test_golden_executable.test_ignores_command_line_arguments[anything]", + "eval.tests.test_golden_executable.test_ignores_stdin", + "eval.tests.test_golden_executable.test_prints_no_stderr", + "eval.tests.test_golden_executable.test_reported_distance_values_ascending_aligned_to_indices", + "eval.tests.test_golden_executable.test_runs_and_exits_zero_with_expected_stdout", + "eval.tests.test_golden_executable.test_second_line_reports_distances_0_18_and_0_38", + "eval.tests.test_golden_executable.test_stdout_has_exactly_two_lines", + "eval.tests.test_golden_executable.test_stdout_reports_exactly_two_neighbor_candidates", + "eval.tests.test_golden_executable.test_stdout_stable_across_runs", + "eval.tests.test_icp.test_affine_icp_converges", + "eval.tests.test_icp.test_affine_icp_recovers_inverse_scale", + "eval.tests.test_icp.test_combined_metric_icp_aligns_cloud", + "eval.tests.test_icp.test_combined_metric_icp_converges", + "eval.tests.test_icp.test_combined_metric_icp_performs_iterations", + "eval.tests.test_icp.test_icp_loose_tolerance_stops_early", + "eval.tests.test_icp.test_icp_max_iterations_caps_large_budget", + "eval.tests.test_icp.test_icp_max_iterations_caps_small_budget", + "eval.tests.test_icp.test_rigid_icp_aligns_cloud", + "eval.tests.test_icp.test_rigid_icp_converges", + "eval.tests.test_icp.test_rigid_icp_last_update_norm_is_small_when_converged", + "eval.tests.test_icp.test_rigid_icp_performs_iterations", + "eval.tests.test_ransac.test_affine_transform_ransac_recovers_scale", + "eval.tests.test_ransac.test_affine_transform_ransac_recovers_translation", + "eval.tests.test_ransac.test_line_ransac_fits_collinear_2d_points", + "eval.tests.test_ransac.test_line_ransac_inlier_count", + "eval.tests.test_ransac.test_plane_ransac_classifies_all_coplanar_points_as_inliers", + "eval.tests.test_ransac.test_plane_ransac_estimate_overload", + "eval.tests.test_ransac.test_plane_ransac_fits_coplanar_points", + "eval.tests.test_ransac.test_plane_ransac_mixed_target_achieved", + "eval.tests.test_ransac.test_plane_ransac_performs_at_least_one_iteration", + "eval.tests.test_ransac.test_plane_ransac_reports_exact_plane_offset", + "eval.tests.test_ransac.test_plane_ransac_robust_to_outliers", + "eval.tests.test_ransac.test_plane_ransac_single_point_does_not_crash", + "eval.tests.test_ransac.test_rigid_transform_ransac_inliers_exhaust_clean_cloud", + "eval.tests.test_ransac.test_rigid_transform_ransac_recovers_rotation_angle", + "eval.tests.test_ransac.test_rigid_transform_ransac_recovers_translation", + "eval.tests.test_ransac.test_rigid_transform_ransac_target_achieved", + "eval.tests.test_transform_estimation.test_affine_transform_estimation_few_points_fails", + "eval.tests.test_transform_estimation.test_affine_transform_estimation_recovers_scale", + "eval.tests.test_transform_estimation.test_affine_transform_estimation_recovers_translation", + "eval.tests.test_transform_estimation.test_affine_transform_estimation_succeeds", + "eval.tests.test_transform_estimation.test_combined_metric_transform_estimation_identity_for_empty_correspondences", + "eval.tests.test_transform_estimation.test_combined_metric_transform_estimation_succeeds", + "eval.tests.test_transform_estimation.test_rigid_transform_estimation_applies_exactly", + "eval.tests.test_transform_estimation.test_rigid_transform_estimation_empty_inputs_fail", + "eval.tests.test_transform_estimation.test_rigid_transform_estimation_recovers_translation", + "eval.tests.test_transform_estimation.test_rigid_transform_estimation_rejects_mismatched_sizes", + "eval.tests.test_transform_estimation.test_rigid_transform_estimation_succeeds" + ] + }, + "generated_module_06": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_stream_topology_and_runtime_dimensions.test_both_streams_discarded_to_dev_null_still_exits_cleanly", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_stream_topology_and_runtime_dimensions.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_stream_topology_and_runtime_dimensions.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_stream_topology_and_runtime_dimensions.test_stderr_merged_into_stdout_to_a_real_file_is_golden_length", + "reasons": [ + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_stream_topology_and_runtime_dimensions.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv0]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv10]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv11]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv12]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv13]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv1]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv2]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv3]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv4]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv5]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv6]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv7]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv8]", + "eval.tests.test_arg_tolerance.test_exit_zero_under_arguments[argv9]", + "eval.tests.test_arg_tolerance.test_large_argument_vector_does_not_break_process", + "eval.tests.test_arg_tolerance.test_numeric_argument_values_ignored", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv0]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv10]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv11]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv12]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv13]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv1]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv2]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv3]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv4]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv5]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv6]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv7]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv8]", + "eval.tests.test_arg_tolerance.test_stdout_digest_invariant_under_arguments[argv9]", + "eval.tests.test_arg_tolerance.test_very_long_argument_value", + "eval.tests.test_cwd_independence.test_output_identical_across_generated_clean_directories", + "eval.tests.test_cwd_independence.test_output_identical_to_current_directory_baseline", + "eval.tests.test_cwd_independence.test_output_invariant_across_system_directories[/]", + "eval.tests.test_cwd_independence.test_output_invariant_across_system_directories[/tmp]", + "eval.tests.test_cwd_independence.test_runs_from_a_directory_containing_decode_payloads", + "eval.tests.test_determinism.test_exit_status_stable_across_repeats", + "eval.tests.test_determinism.test_interleaved_invocations_do_not_interfere", + "eval.tests.test_determinism.test_repeated_runs_are_byte_identical", + "eval.tests.test_determinism.test_repeated_runs_share_a_stable_digest", + "eval.tests.test_environment_and_invocation_contract.test_binary_file_copied_to_another_name_and_directory", + "eval.tests.test_environment_and_invocation_contract.test_cleared_environment_with_garbage_args_keeps_golden_output", + "eval.tests.test_environment_and_invocation_contract.test_help_flag_does_not_emit_usage_or_change_output", + "eval.tests.test_environment_and_invocation_contract.test_invocation_via_symlink_preserves_output", + "eval.tests.test_environment_and_invocation_contract.test_launch_from_absolute_utility_path_shows_golden_output", + "eval.tests.test_environment_and_invocation_contract.test_maximal_stress_launch_context", + "eval.tests.test_environment_and_invocation_contract.test_stdout_identical_under_cleared_environment", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override0]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override1]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override2]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override3]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override4]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override5]", + "eval.tests.test_environment_and_invocation_contract.test_stdout_invariant_under_environment_override[override6]", + "eval.tests.test_environment_and_invocation_contract.test_succeeds_from_read_only_working_directory", + "eval.tests.test_environment_and_invocation_contract.test_succeeds_without_a_writable_tmp_dir", + "eval.tests.test_environment_and_invocation_contract.test_version_flag_does_not_print_a_version_banner", + "eval.tests.test_exit_status.test_exit_status_is_int_zero_not_truthy_marker", + "eval.tests.test_exit_status.test_exit_status_is_zero_with_no_args", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv0]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv1]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv2]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv3]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv4]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv5]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv6]", + "eval.tests.test_exit_status.test_exit_status_stable_across_cli_argument_vectors[argv7]", + "eval.tests.test_exit_status.test_exit_status_zero_even_when_args_are_garbage", + "eval.tests.test_exit_status.test_exit_status_zero_from_nonempty_working_directory", + "eval.tests.test_no_side_effects.test_directory_remains_empty_of_nonempty_files", + "eval.tests.test_no_side_effects.test_executable_itself_untouched", + "eval.tests.test_no_side_effects.test_no_files_created_in_clean_working_directory", + "eval.tests.test_no_side_effects.test_no_partial_artifacts_after_run", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_concurrent_alternating_launch_and_consumption_stays_isolated", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_concurrent_processes_produce_identical_isolated_output", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdin_as_directory_fd_is_ignored", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdin_closed_before_program_relative_input_exists", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdin_with_closed_read_end_is_not_blocking", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdout_identical_under_lang_and_language_overrides", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdout_is_identical_under_any_lc_all_value", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdout_write_failure_to_dev_full_does_not_hang_or_crash", + "eval.tests.test_process_locale_concurrency_and_io_failure.test_stdout_write_to_directory_fd_does_not_crash", + "eval.tests.test_process_stream_and_format_contract.test_golden_resource_is_consistent_with_expected_bytes", + "eval.tests.test_process_stream_and_format_contract.test_many_sequential_processes_all_deliver_identical_pipe_bytes", + "eval.tests.test_process_stream_and_format_contract.test_numeric_fields_use_fixed_format_width", + "eval.tests.test_process_stream_and_format_contract.test_stderr_is_byte_empty_through_pipe", + "eval.tests.test_process_stream_and_format_contract.test_stdin_read_would_fail_yet_output_is_unchanged", + "eval.tests.test_process_stream_and_format_contract.test_stdout_consists_only_of_printable_ascii_and_newlines", + "eval.tests.test_process_stream_and_format_contract.test_stdout_exact_byte_length_is_fixed", + "eval.tests.test_process_stream_and_format_contract.test_stdout_redirected_to_real_file_is_byte_identical", + "eval.tests.test_process_stream_and_format_contract.test_stdout_survives_os_level_pipe_as_exact_golden_bytes", + "eval.tests.test_runtime_bound.test_completes_well_under_hard_timeout", + "eval.tests.test_runtime_bound.test_does_not_spawn_zombie_children", + "eval.tests.test_runtime_bound.test_hard_timeout_never_triggered_in_clean_run", + "eval.tests.test_runtime_bound.test_saturating_stdout_pipe_does_not_deadlock", + "eval.tests.test_semantic_oracle.test_distances_are_ascending_and_non_negative", + "eval.tests.test_semantic_oracle.test_exactly_two_neighbors_returned", + "eval.tests.test_semantic_oracle.test_first_distance_is_vertex_zero_squared_distance", + "eval.tests.test_semantic_oracle.test_neighbor_distances_match_ground_truth_squared_distances", + "eval.tests.test_semantic_oracle.test_neighbor_indices_match_independently_computed_nearest_set", + "eval.tests.test_semantic_oracle.test_neighbors_are_distinct_vertices", + "eval.tests.test_semantic_oracle.test_output_distances_are_consistent_index_ordered", + "eval.tests.test_semantic_oracle.test_query_is_open_space_near_edges", + "eval.tests.test_semantic_oracle.test_second_distance_is_vertex_three_squared_distance", + "eval.tests.test_stderr_contract.test_no_error_keywords_on_stderr", + "eval.tests.test_stderr_contract.test_stderr_and_stdout_are_segregated", + "eval.tests.test_stderr_contract.test_stderr_is_empty_normally", + "eval.tests.test_stderr_contract.test_stderr_stays_empty_with_arguments", + "eval.tests.test_stdin_tolerance.test_closed_stdin_is_not_consumed_or_blocking", + "eval.tests.test_stdin_tolerance.test_large_stdin_stream_does_not_perturb", + "eval.tests.test_stdin_tolerance.test_stdin_with_binary_noise_is_ignored", + "eval.tests.test_stdin_tolerance.test_stdin_with_data_does_not_change_output", + "eval.tests.test_stdout_contract.test_stdout_contains_both_neighbor_labels", + "eval.tests.test_stdout_contract.test_stdout_distances_line_exact", + "eval.tests.test_stdout_contract.test_stdout_distances_values_are_finite_floats", + "eval.tests.test_stdout_contract.test_stdout_exact_full_match", + "eval.tests.test_stdout_contract.test_stdout_has_exactly_two_nonempty_lines", + "eval.tests.test_stdout_contract.test_stdout_identical_regardless_of_args[argv0]", + "eval.tests.test_stdout_contract.test_stdout_identical_regardless_of_args[argv1]", + "eval.tests.test_stdout_contract.test_stdout_identical_regardless_of_args[argv2]", + "eval.tests.test_stdout_contract.test_stdout_identical_regardless_of_args[argv3]", + "eval.tests.test_stdout_contract.test_stdout_indices_are_nonnegative_integers", + "eval.tests.test_stdout_contract.test_stdout_indices_line_exact", + "eval.tests.test_stdout_contract.test_stdout_lines_order_is_indices_then_distances", + "eval.tests.test_stdout_contract.test_stdout_trailing_newline_present", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_both_streams_discarded_to_dev_null_still_exits_cleanly", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_invalid_ompi_thread_count_keeps_golden_output_but_spots_runtime_diag", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_omp_value_of_zero_with_stdout_to_dev_null_exits_cleanly", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_oversized_but_valid_omp_thread_count_stays_silent", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_stderr_merged_into_stdout_is_exactly_golden_bytes", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_stderr_merged_into_stdout_to_a_real_file_is_golden_length", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_stdin_from_dev_null_is_ignored_and_output_is_golden", + "eval.tests.test_stream_topology_and_runtime_dimensions.test_stdout_discarded_to_dev_null_still_exits_cleanly" + ] + } + }, + "commit": "cd473ebcc5ac0f9e03d0b7f462bb742b1e987872", + "data_source": "synthetic_programgym", + "difficulty": "medium", + "difficulty_score": 3.4615225368715867, + "eval_clean_hashes": [ + "0fe490dfc3e6e5a386d9ed219468ff801f9cfdec48270c2e4df6f3a3333b16e1" + ], + "input_record": { + "commit": "cd473ebcc5ac0f9e03d0b7f462bb742b1e987872", + "difficulty": "medium", + "difficulty_code_lines": 72354, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 72354, + "difficulty_runtime_deps": 3, + "difficulty_score": 3.4615225368715867, + "difficulty_test_code_lines": 2165, + "full_name": "kzampog/cilantro", + "input_joern_zip": "cpp_joern/kzampog__cilantro.zip", + "joern_status": true, + "joern_time": 35.35340995597653, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 464, + "similarity": 0.4826785922050476 + }, + { + "pb_fullname": "OSGeo/gdal", + "rank": 346, + "similarity": 0.4588759243488312 + }, + { + "pb_fullname": "OSGeo/PROJ", + "rank": 341, + "similarity": 0.41855138540267944 + } + ], + "repo_path": "cpp/kzampog__cilantro", + "source": "commit:cd473ebcc5ac0f9e03d0b7f462bb742b1e987872", + "status": "done", + "url": "https://github.com/kzampog/cilantro" + }, + "instance_id": "kzampog__cilantro.cd473eb", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 15, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 15, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_03", + "iteration_limit": 15, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 15, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_05", + "iteration_limit": 15, + "module_index": 5, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_06", + "iteration_limit": 15, + "module_index": 6, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "kzampog/cilantro" +} diff --git a/kzampog--cilantro.cd473eb/tests/test.sh b/kzampog--cilantro.cd473eb/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/kzampog--cilantro.cd473eb/tests/workspace.tar.gz b/kzampog--cilantro.cd473eb/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..66bb513d2cf8e3cd7af95fbe2ee024a85cda377d --- /dev/null +++ b/kzampog--cilantro.cd473eb/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a833417a1a0190cecdd0fe928995419e43c948bbc97245b21d027afb4d6fffb2 +size 3792 diff --git a/lagadic--visp.22e3a84/environment/Dockerfile b/lagadic--visp.22e3a84/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..1bcfa04437d24f8eb8652a133e82f9c25c0c57a0 --- /dev/null +++ b/lagadic--visp.22e3a84/environment/Dockerfile @@ -0,0 +1,64 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build python3-pytest python3-pytest-xdist python3-coverage curl tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/lagadic--visp.22e3a84/environment/docker-compose.yaml b/lagadic--visp.22e3a84/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lagadic--visp.22e3a84/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lagadic--visp.22e3a84/environment/download.sh b/lagadic--visp.22e3a84/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..b6082f9acbe7cf976cc0f910f2bfc7402eb04aa6 --- /dev/null +++ b/lagadic--visp.22e3a84/environment/download.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +# +# ProgramGym download stage for lagadic/visp. +# source /source_ro/download.sh +# +# The selected target (parse-argv1, see single.json) is built offline with the +# USE_EIGEN3=OFF configuration, which selects the vendored built-in clapack +# linear-algebra backend (3rdparty/clapack) for visp_core. As a result the build +# requires NO external -dev packages: the project's build-config generator and +# the C/C++ toolchain are already shipped in the base image, and every +# third-party component the final static binary pulls in (clapack, pugixml, +# simdlib, stb_image) is vendored under 3rdparty/ in the repository tree. +# +# This script therefore performs no package setup and no build step. It only +# exports the environment variables that the offline build.sh relies on, and it +# does not read any repository file -- every piece of build metadata is written +# explicitly in build.sh. +# +# This script is safe to source: it uses only exports, no positional arguments, +# and never exits in its normal control flow. Every variable reference uses the +# ${VAR:-default} form so it is safe even when the sourcing shell runs with +# set -u (nounset). + +# Number of parallel compile jobs used by the offline build.sh. Keep it small +# enough to be safe on constrained CI runners. The ${VAR:-default} form +# guarantees the variable is always bound, even if the sourcing shell set -u. +export VISP_BUILD_JOBS="${VISP_BUILD_JOBS:-4}" + +# The build-config generator and the C/C++ toolchain are verified to be present +# in the base image, and no package setup is required, so there is nothing to +# download or prefetch here. If the offline build stage later finds a tool +# missing, build.sh fails loudly with a non-zero exit rather than hiding it. + +printf '%s\n' "download.sh: ready (no external dependencies required); VISP_BUILD_JOBS=${VISP_BUILD_JOBS}" diff --git a/lagadic--visp.22e3a84/environment/executable b/lagadic--visp.22e3a84/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..437ed8c31a1097e15b5b7027a93e05f3330ea9ec Binary files /dev/null and b/lagadic--visp.22e3a84/environment/executable differ diff --git a/lagadic--visp.22e3a84/environment/harbor_configure_apt_mirror.sh b/lagadic--visp.22e3a84/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lagadic--visp.22e3a84/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lagadic--visp.22e3a84/environment/harbor_prepare_download_env.sh b/lagadic--visp.22e3a84/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lagadic--visp.22e3a84/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lagadic--visp.22e3a84/environment/workspace.tar.gz b/lagadic--visp.22e3a84/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..fdeb6468404524be62348b1e21b838408ec509af --- /dev/null +++ b/lagadic--visp.22e3a84/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3f1a317018067cabb15ddb855ac86e868444f9d31b082b8d87a0fbaa9a95003c +size 8138 diff --git a/lagadic--visp.22e3a84/instruction.md b/lagadic--visp.22e3a84/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/lagadic--visp.22e3a84/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/lagadic--visp.22e3a84/solution/solve.sh b/lagadic--visp.22e3a84/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/lagadic--visp.22e3a84/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/lagadic--visp.22e3a84/task.toml b/lagadic--visp.22e3a84/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1fea10c6eeb2dd8f67bfa58ade62be3670d3490a --- /dev/null +++ b/lagadic--visp.22e3a84/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/lagadic--visp.22e3a84" +description = "Synthetic ProgramGym cleanroom reconstruction task for lagadic/visp" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "lagadic__visp.22e3a84" +repository = "lagadic/visp" +commit = "22e3a84e7f1fc8cacda0f6a0843dfad8a2ca6487" +language = "cpp" +difficulty = "hard" +difficulty_score = 4.686427114155551 +test_branches = 7 +test_count = 272 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/lagadic--visp.22e3a84/tests/Dockerfile b/lagadic--visp.22e3a84/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ef45becedb352d71e0d28eefebe80e3c73de2bd3 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/Dockerfile @@ -0,0 +1,72 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build python3-pytest python3-pytest-xdist python3-coverage curl tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_01.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8db6143488cf132915ed1f78f1c45d2e0ad49657 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c70f261ca9b80dc4dc020c7fd6a205e7eb87b39bc6cb116392c66c41bdd15a25 +size 7722 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_02.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..aa0545047c81daaa14d366cb4568dbe8f0b828f2 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40f2e94cf0c52b8d00b159f71b0c09df2a8f503da33c4fcad2bfcb034d346278 +size 7987 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_03.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8d5b4b481e6c4551c7646edcba6ff773115fc696 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30c26b6c4edd409ef413540a1b4f9d74ef51899169f887bbc846bbd7a63b2d57 +size 4928 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_04.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..33cdf63658ca4cc3491cfb64bdd566143ccc5429 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c276dc0aa46b4c027d4d51e26e9a777ca76b639bce264fb122bfca29dc43fbe +size 7544 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_05.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_05.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..84b7cf3ad88e7a0d4510133dbd840b05e748b37d --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_05.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00325090deaa51387102ae7179bc6f7652fa593591d09d2b2a486aca1e98cee1 +size 6667 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_06.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_06.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0f7044a468345cfa5433c97c424a3b2ee465178d --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_06.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0017e66f2379bcb9764d71d72f79a4e4a4e6231f612a3cf98e0d0daee7141fa7 +size 4392 diff --git a/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_08.tar.gz b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_08.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3fc39311fb99430687f46fc8dfa54b524fec0c21 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/blobs/tests/generated_module_08.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ea151b4f20952095ee0266d4a862864fbab572a8e058d8be562bc2e9b4230e1 +size 12956 diff --git a/lagadic--visp.22e3a84/tests/docker-compose.yaml b/lagadic--visp.22e3a84/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lagadic--visp.22e3a84/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lagadic--visp.22e3a84/tests/download.sh b/lagadic--visp.22e3a84/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..b6082f9acbe7cf976cc0f910f2bfc7402eb04aa6 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/download.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +# +# ProgramGym download stage for lagadic/visp. +# source /source_ro/download.sh +# +# The selected target (parse-argv1, see single.json) is built offline with the +# USE_EIGEN3=OFF configuration, which selects the vendored built-in clapack +# linear-algebra backend (3rdparty/clapack) for visp_core. As a result the build +# requires NO external -dev packages: the project's build-config generator and +# the C/C++ toolchain are already shipped in the base image, and every +# third-party component the final static binary pulls in (clapack, pugixml, +# simdlib, stb_image) is vendored under 3rdparty/ in the repository tree. +# +# This script therefore performs no package setup and no build step. It only +# exports the environment variables that the offline build.sh relies on, and it +# does not read any repository file -- every piece of build metadata is written +# explicitly in build.sh. +# +# This script is safe to source: it uses only exports, no positional arguments, +# and never exits in its normal control flow. Every variable reference uses the +# ${VAR:-default} form so it is safe even when the sourcing shell runs with +# set -u (nounset). + +# Number of parallel compile jobs used by the offline build.sh. Keep it small +# enough to be safe on constrained CI runners. The ${VAR:-default} form +# guarantees the variable is always bound, even if the sourcing shell set -u. +export VISP_BUILD_JOBS="${VISP_BUILD_JOBS:-4}" + +# The build-config generator and the C/C++ toolchain are verified to be present +# in the base image, and no package setup is required, so there is nothing to +# download or prefetch here. If the offline build stage later finds a tool +# missing, build.sh fails loudly with a non-zero exit rather than hiding it. + +printf '%s\n' "download.sh: ready (no external dependencies required); VISP_BUILD_JOBS=${VISP_BUILD_JOBS}" diff --git a/lagadic--visp.22e3a84/tests/executable b/lagadic--visp.22e3a84/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..437ed8c31a1097e15b5b7027a93e05f3330ea9ec Binary files /dev/null and b/lagadic--visp.22e3a84/tests/executable differ diff --git a/lagadic--visp.22e3a84/tests/harbor_configure_apt_mirror.sh b/lagadic--visp.22e3a84/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lagadic--visp.22e3a84/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lagadic--visp.22e3a84/tests/harbor_prepare_download_env.sh b/lagadic--visp.22e3a84/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lagadic--visp.22e3a84/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lagadic--visp.22e3a84/tests/programgym_evaluator.py b/lagadic--visp.22e3a84/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/lagadic--visp.22e3a84/tests/programgym_task.json b/lagadic--visp.22e3a84/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..6d47ab83f990b585256604553bb56054df9ca313 --- /dev/null +++ b/lagadic--visp.22e3a84/tests/programgym_task.json @@ -0,0 +1,420 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_parse_argv.test_bare_dash_is_a_bad_argument", + "eval.tests.test_parse_argv.test_case_sensitive_options_reject_uppercase", + "eval.tests.test_parse_argv.test_combined_options_all_apply", + "eval.tests.test_parse_argv.test_default_invocation_prints_defaults_and_succeeds", + "eval.tests.test_parse_argv.test_double_dash_alone_is_a_bad_argument", + "eval.tests.test_parse_argv.test_double_dash_long_option_is_unrecognized", + "eval.tests.test_parse_argv.test_double_option_empty_string_argument_is_zero", + "eval.tests.test_parse_argv.test_double_option_fraction", + "eval.tests.test_parse_argv.test_double_option_high_precision_rounded", + "eval.tests.test_parse_argv.test_double_option_integer_literal", + "eval.tests.test_parse_argv.test_double_option_missing_argument_is_error", + "eval.tests.test_parse_argv.test_double_option_negative_value", + "eval.tests.test_parse_argv.test_double_option_sets_value", + "eval.tests.test_parse_argv.test_double_value_crosses_exponent_formatting_threshold", + "eval.tests.test_parse_argv.test_double_value_large_exponent_rendering", + "eval.tests.test_parse_argv.test_float_high_precision_value_rounds_to_six_digits", + "eval.tests.test_parse_argv.test_float_option_empty_string_argument_is_zero", + "eval.tests.test_parse_argv.test_float_option_missing_argument_is_error", + "eval.tests.test_parse_argv.test_float_option_negative_and_decimal", + "eval.tests.test_parse_argv.test_float_option_scientific_notation", + "eval.tests.test_parse_argv.test_float_option_sets_value", + "eval.tests.test_parse_argv.test_float_option_trailing_suffix_is_ignored_by_atof", + "eval.tests.test_parse_argv.test_float_option_truncates_trailing_zeros", + "eval.tests.test_parse_argv.test_float_value_crosses_exponent_formatting_threshold", + "eval.tests.test_parse_argv.test_float_value_large_exponent_rendering", + "eval.tests.test_parse_argv.test_help_among_valid_options_stops_parsing_and_prints_usage", + "eval.tests.test_parse_argv.test_help_block_renders_all_staged_defaults_together", + "eval.tests.test_parse_argv.test_help_block_renders_staged_double_default", + "eval.tests.test_parse_argv.test_help_block_renders_staged_float_default", + "eval.tests.test_parse_argv.test_help_marker_among_invalid_options_still_reports_bad_argument", + "eval.tests.test_parse_argv.test_help_prints_usage_and_exits_failure", + "eval.tests.test_parse_argv.test_integer_explicit_sign_is_accepted", + "eval.tests.test_parse_argv.test_integer_hex_literal_stops_at_nondecimal_prefix", + "eval.tests.test_parse_argv.test_integer_option_aliased_atof_semantics_for_non_numeric", + "eval.tests.test_parse_argv.test_integer_option_attached_negative", + "eval.tests.test_parse_argv.test_integer_option_attached_value", + "eval.tests.test_parse_argv.test_integer_option_consumes_an_option_like_token_as_its_value", + "eval.tests.test_parse_argv.test_integer_option_date_like_value_parses_leading_digits", + "eval.tests.test_parse_argv.test_integer_option_empty_string_argument_is_zero", + "eval.tests.test_parse_argv.test_integer_option_missing_argument_is_error", + "eval.tests.test_parse_argv.test_integer_option_negative_value", + "eval.tests.test_parse_argv.test_integer_option_sets_value", + "eval.tests.test_parse_argv.test_integer_option_zero", + "eval.tests.test_parse_argv.test_integer_overflow_wraps_to_negative_minimum", + "eval.tests.test_parse_argv.test_integer_then_float_then_double_order_independent", + "eval.tests.test_parse_argv.test_integer_underflow_wraps_to_positive_maximum", + "eval.tests.test_parse_argv.test_integer_wraps_modulo_2_32_for_huge_value", + "eval.tests.test_parse_argv.test_numeric_option_character_is_unrecognized", + "eval.tests.test_parse_argv.test_plus_prefixed_token_is_a_standalone_parameter", + "eval.tests.test_parse_argv.test_repeated_integer_option_last_wins", + "eval.tests.test_parse_argv.test_slash_option_is_treated_as_positional", + "eval.tests.test_parse_argv.test_standalone_positional_argument_is_error", + "eval.tests.test_parse_argv.test_unrecognized_option_is_error" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_parse_argv.test_all_flags_together", + "eval.tests.test_parse_argv.test_attached_float_rounds_through_ostream", + "eval.tests.test_parse_argv.test_attached_float_scientific_value", + "eval.tests.test_parse_argv.test_attached_integer_option", + "eval.tests.test_parse_argv.test_attached_integer_with_trailing_garbage", + "eval.tests.test_parse_argv.test_attached_negative_double", + "eval.tests.test_parse_argv.test_attached_negative_integer", + "eval.tests.test_parse_argv.test_attached_then_space_value_last_wins", + "eval.tests.test_parse_argv.test_attached_value_then_help_shows_value", + "eval.tests.test_parse_argv.test_bare_positional_token_rejected", + "eval.tests.test_parse_argv.test_bare_punct_token_rejected", + "eval.tests.test_parse_argv.test_double_flag_overrides_default", + "eval.tests.test_parse_argv.test_double_nan_round_trips", + "eval.tests.test_parse_argv.test_double_negative_zero_kept", + "eval.tests.test_parse_argv.test_double_option_swallows_dash_prefixed_token", + "eval.tests.test_parse_argv.test_double_overflow_becomes_inf", + "eval.tests.test_parse_argv.test_double_scientific_notation", + "eval.tests.test_parse_argv.test_float_flag_overrides_default", + "eval.tests.test_parse_argv.test_float_nan_round_trips", + "eval.tests.test_parse_argv.test_float_negative_overflow_becomes_neg_inf", + "eval.tests.test_parse_argv.test_float_overflow_becomes_inf", + "eval.tests.test_parse_argv.test_float_precision_truncation", + "eval.tests.test_parse_argv.test_float_scientific_power_notation", + "eval.tests.test_parse_argv.test_help_after_parsing_valid_option_shows_new_value", + "eval.tests.test_parse_argv.test_help_combined_values_show_all_three_modified_rows", + "eval.tests.test_parse_argv.test_help_double_row_negative_zero_shortest", + "eval.tests.test_parse_argv.test_help_double_row_renders_inf", + "eval.tests.test_parse_argv.test_help_double_row_rounds_at_six_significant_digits", + "eval.tests.test_parse_argv.test_help_double_row_uses_shortest_representation", + "eval.tests.test_parse_argv.test_help_double_very_small_value_switches_to_scientific", + "eval.tests.test_parse_argv.test_help_flag_prints_usage_and_stops", + "eval.tests.test_parse_argv.test_help_float_row_negative_zero_fixed_six_decimals", + "eval.tests.test_parse_argv.test_help_float_row_renders_inf", + "eval.tests.test_parse_argv.test_help_float_row_renders_nan", + "eval.tests.test_parse_argv.test_help_float_row_rounds_at_six_decimal_places", + "eval.tests.test_parse_argv.test_help_float_row_uses_fixed_six_decimal_format", + "eval.tests.test_parse_argv.test_help_float_tiny_value_underflows_to_zero", + "eval.tests.test_parse_argv.test_int_overflow_wraps_negative", + "eval.tests.test_parse_argv.test_int_positive_sign_and_max", + "eval.tests.test_parse_argv.test_int_underflow_wraps_positive", + "eval.tests.test_parse_argv.test_integer_flag_overrides_default", + "eval.tests.test_parse_argv.test_integer_zero_and_negative", + "eval.tests.test_parse_argv.test_large_double_switches_to_scientific", + "eval.tests.test_parse_argv.test_large_float_switches_to_scientific", + "eval.tests.test_parse_argv.test_leading_dash_double_dash_option_rejected", + "eval.tests.test_parse_argv.test_missing_float_argument_after_valid_rejected", + "eval.tests.test_parse_argv.test_missing_option_argument_rejected", + "eval.tests.test_parse_argv.test_mixed_attached_and_space_form_options", + "eval.tests.test_parse_argv.test_negative_float_zero_kept", + "eval.tests.test_parse_argv.test_no_arguments_prints_defaults_and_succeeds", + "eval.tests.test_parse_argv.test_non_numeric_double_arg_parses_to_zero", + "eval.tests.test_parse_argv.test_non_numeric_int_arg_parses_to_zero", + "eval.tests.test_parse_argv.test_option_looking_token_consumed_as_value", + "eval.tests.test_parse_argv.test_punct_option_char_rejected", + "eval.tests.test_parse_argv.test_repeated_flag_last_wins", + "eval.tests.test_parse_argv.test_seven_sig_fig_double_switches_to_scientific", + "eval.tests.test_parse_argv.test_single_dash_rejected", + "eval.tests.test_parse_argv.test_trailing_standalone_arg_after_valid_option_rejected", + "eval.tests.test_parse_argv.test_unknown_long_option_rejected", + "eval.tests.test_parse_argv.test_unknown_option_after_valid_still_rejected", + "eval.tests.test_parse_argv.test_unknown_short_option_rejected", + "eval.tests.test_parse_argv.test_very_small_double_switches_to_scientific" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_parse_argv.test_bad_argument_errors[invalid-option]", + "eval.tests.test_parse_argv.test_bad_argument_errors[missing-value]", + "eval.tests.test_parse_argv.test_bad_argument_errors[standalone-positional]", + "eval.tests.test_parse_argv.test_combined_options_are_all_updated", + "eval.tests.test_parse_argv.test_exit_failure_is_exactly_one[help]", + "eval.tests.test_parse_argv.test_exit_failure_is_exactly_one[invalid]", + "eval.tests.test_parse_argv.test_exit_failure_is_exactly_one[missing]", + "eval.tests.test_parse_argv.test_exit_failure_is_exactly_one[mixed]", + "eval.tests.test_parse_argv.test_exit_failure_is_exactly_one[standalone]", + "eval.tests.test_parse_argv.test_exit_success_is_exactly_zero[all]", + "eval.tests.test_parse_argv.test_exit_success_is_exactly_zero[double]", + "eval.tests.test_parse_argv.test_exit_success_is_exactly_zero[float]", + "eval.tests.test_parse_argv.test_exit_success_is_exactly_zero[int]", + "eval.tests.test_parse_argv.test_exit_success_is_exactly_zero[no-args]", + "eval.tests.test_parse_argv.test_float_uses_stream_default_precision", + "eval.tests.test_parse_argv.test_help_exit_code_and_stdout_golden", + "eval.tests.test_parse_argv.test_mixed_valid_and_invalid_is_rejected", + "eval.tests.test_parse_argv.test_negative_integer_value", + "eval.tests.test_parse_argv.test_no_args_prints_defaults_exit_zero", + "eval.tests.test_parse_argv.test_option_order_does_not_change_result", + "eval.tests.test_parse_argv.test_set_double", + "eval.tests.test_parse_argv.test_set_float", + "eval.tests.test_parse_argv.test_set_integer", + "eval.tests.test_parse_argv.test_valid_stdout_matches_golden_params" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_parse_argv.test_default_parameters_with_no_arguments", + "eval.tests.test_parse_argv.test_help_prints_full_usage_block_to_stdout", + "eval.tests.test_parse_argv.test_help_writes_nothing_to_stderr", + "eval.tests.test_parse_argv.test_int_max_round_trips", + "eval.tests.test_parse_argv.test_missing_option_value_reports_bad_argument", + "eval.tests.test_parse_argv.test_negative_zero_and_scientific_values", + "eval.tests.test_parse_argv.test_non_numeric_value_parses_to_zero", + "eval.tests.test_parse_argv.test_option_flag_used_as_value_is_consumed", + "eval.tests.test_parse_argv.test_options_order_independent", + "eval.tests.test_parse_argv.test_partially_numeric_double_keeps_leading_number", + "eval.tests.test_parse_argv.test_set_all_numeric_options", + "eval.tests.test_parse_argv.test_single_option_keeps_defaults_for_others", + "eval.tests.test_parse_argv.test_standalone_positional_argument_rejected", + "eval.tests.test_parse_argv.test_unknown_option_reports_bad_argument", + "eval.tests.test_parse_argv_inline_repeat.test_all_inline_values_bind_together", + "eval.tests.test_parse_argv_inline_repeat.test_help_short_circuits_later_options_keeps_defaults", + "eval.tests.test_parse_argv_inline_repeat.test_inline_int_value_without_space", + "eval.tests.test_parse_argv_inline_repeat.test_inline_negative_float_value_without_space", + "eval.tests.test_parse_argv_inline_repeat.test_inline_scientific_double_value_without_space", + "eval.tests.test_parse_argv_inline_repeat.test_repeated_and_combined_options_keep_last_of_each", + "eval.tests.test_parse_argv_inline_repeat.test_repeated_double_option_keeps_last_value", + "eval.tests.test_parse_argv_inline_repeat.test_repeated_float_option_keeps_last_value", + "eval.tests.test_parse_argv_inline_repeat.test_repeated_int_option_keeps_last_value", + "eval.tests.test_parse_argv_interactions.test_help_after_all_options_reflects_all_parsed_values", + "eval.tests.test_parse_argv_interactions.test_help_after_double_option_uses_g_format", + "eval.tests.test_parse_argv_interactions.test_help_after_float_option_uses_float_format", + "eval.tests.test_parse_argv_interactions.test_help_after_int_option_reflects_parsed_value", + "eval.tests.test_parse_argv_interactions.test_unknown_option_after_valid_option_keeps_parsed_value_in_diagnostic" + ] + }, + "generated_module_05": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_numeric_extremes.test_double_large_finite_uses_scientific_notation", + "eval.tests.test_numeric_extremes.test_double_nan_renders_nan", + "eval.tests.test_numeric_extremes.test_double_overflow_renders_negative_infinity", + "eval.tests.test_numeric_extremes.test_double_overflow_renders_positive_infinity", + "eval.tests.test_numeric_extremes.test_float_overflow_renders_infinity", + "eval.tests.test_parse_argv.test_adjacent_flag_tokens_reveal_option_argument_semantics", + "eval.tests.test_parse_argv.test_all_options_together", + "eval.tests.test_parse_argv.test_default_parameters_with_no_arguments", + "eval.tests.test_parse_argv.test_default_run_writes_nothing_to_stderr", + "eval.tests.test_parse_argv.test_double_option_missing_value_is_rejected", + "eval.tests.test_parse_argv.test_double_option_only_changes_double", + "eval.tests.test_parse_argv.test_double_scientific_notation_printing", + "eval.tests.test_parse_argv.test_error_reports_fail_to_stderr_not_stdout", + "eval.tests.test_parse_argv.test_float_option_missing_value_is_rejected", + "eval.tests.test_parse_argv.test_float_option_only_changes_float", + "eval.tests.test_parse_argv.test_float_precision_truncation", + "eval.tests.test_parse_argv.test_help_after_an_option_reflects_updated_value", + "eval.tests.test_parse_argv.test_help_double_dash_is_rejected", + "eval.tests.test_parse_argv.test_help_short_flag_reports_usage_and_nonzero_exit", + "eval.tests.test_parse_argv.test_integer_option_missing_value_is_rejected", + "eval.tests.test_parse_argv.test_integer_option_only_changes_integer", + "eval.tests.test_parse_argv.test_integer_valued_float_printer", + "eval.tests.test_parse_argv.test_large_integer_max_int", + "eval.tests.test_parse_argv.test_malformed_float_string_degrades_to_zero", + "eval.tests.test_parse_argv.test_malformed_integer_string_degrades_to_zero", + "eval.tests.test_parse_argv.test_negative_float", + "eval.tests.test_parse_argv.test_negative_integer", + "eval.tests.test_parse_argv.test_options_are_order_independent", + "eval.tests.test_parse_argv.test_standalone_positional_argument_is_rejected", + "eval.tests.test_parse_argv.test_unknown_long_option_is_rejected", + "eval.tests.test_parse_argv.test_unknown_short_option_is_rejected", + "eval.tests.test_parse_argv.test_zero_explicitly_parsed" + ] + }, + "generated_module_06": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_parse_argv_behavior.test_all_overrides_combined", + "eval.tests.test_parse_argv_behavior.test_default_parameters", + "eval.tests.test_parse_argv_behavior.test_double_override", + "eval.tests.test_parse_argv_behavior.test_double_override_rounds_fractional_mantissa", + "eval.tests.test_parse_argv_behavior.test_double_override_rounds_to_six_sig_figs", + "eval.tests.test_parse_argv_behavior.test_executable_is_a_real_file", + "eval.tests.test_parse_argv_behavior.test_exponential_double_input", + "eval.tests.test_parse_argv_behavior.test_exponential_float_input", + "eval.tests.test_parse_argv_behavior.test_float_override", + "eval.tests.test_parse_argv_behavior.test_float_override_decimal_preserved", + "eval.tests.test_parse_argv_behavior.test_help_after_float_option_reflects_float_value", + "eval.tests.test_parse_argv_behavior.test_help_after_normal_options", + "eval.tests.test_parse_argv_behavior.test_help_primacy_over_bad_option", + "eval.tests.test_parse_argv_behavior.test_help_short_flag", + "eval.tests.test_parse_argv_behavior.test_integer_override", + "eval.tests.test_parse_argv_behavior.test_integer_override_tracks_new_value_in_banner", + "eval.tests.test_parse_argv_behavior.test_large_double_uses_scientific_notation", + "eval.tests.test_parse_argv_behavior.test_lone_positional_argument_is_rejected", + "eval.tests.test_parse_argv_behavior.test_long_option_is_rejected", + "eval.tests.test_parse_argv_behavior.test_missing_double_value", + "eval.tests.test_parse_argv_behavior.test_missing_float_value", + "eval.tests.test_parse_argv_behavior.test_missing_integer_value", + "eval.tests.test_parse_argv_behavior.test_negative_float", + "eval.tests.test_parse_argv_behavior.test_negative_integer", + "eval.tests.test_parse_argv_behavior.test_no_files_are_created_by_invocation", + "eval.tests.test_parse_argv_behavior.test_non_numeric_integer_value_coerces_to_zero", + "eval.tests.test_parse_argv_behavior.test_options_can_appear_in_any_order", + "eval.tests.test_parse_argv_behavior.test_repeated_float_option_last_wins", + "eval.tests.test_parse_argv_behavior.test_repeated_option_last_wins", + "eval.tests.test_parse_argv_behavior.test_tiny_double_uses_scientific_notation", + "eval.tests.test_parse_argv_behavior.test_unknown_option_after_valid_options", + "eval.tests.test_parse_argv_behavior.test_unknown_short_option", + "eval.tests.test_parse_argv_behavior.test_zero_integer" + ] + }, + "generated_module_08": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_attached_value_mixed_form", + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_double_output_precision_g", + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_integer_partial_parse_stops_at_garbage", + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_partial_float_and_double_parse_stops_at_garbage", + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_scientific_double", + "eval.tests.test_module08_blackbox.TestAttachedAndPartialParsing.test_signed_exponent_double_branch", + "eval.tests.test_module08_blackbox.TestDefaults.test_all_options_bound", + "eval.tests.test_module08_blackbox.TestDefaults.test_no_args_prints_defaults", + "eval.tests.test_module08_blackbox.TestDefaults.test_partial_option_only_double_changes", + "eval.tests.test_module08_blackbox.TestDefaults.test_partial_option_only_int_changes", + "eval.tests.test_module08_blackbox.TestDeterminism.test_help_is_stable", + "eval.tests.test_module08_blackbox.TestDeterminism.test_repeat_invocation_is_stable", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_double_dash_is_bad_argument", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_missing_value_reports_bad_argument", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_standalone_positional_reports_bad_argument", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_trailing_option_missing_value", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_unknown_long_option", + "eval.tests.test_module08_blackbox.TestErrorDiagnostics.test_unknown_short_option", + "eval.tests.test_module08_blackbox.TestExponentialFormatting.test_double_just_below_exponential_stays_fixed", + "eval.tests.test_module08_blackbox.TestExponentialFormatting.test_double_large_switches_to_exponential", + "eval.tests.test_module08_blackbox.TestExponentialFormatting.test_double_small_switches_to_exponential", + "eval.tests.test_module08_blackbox.TestExponentialFormatting.test_float_large_switches_to_exponential", + "eval.tests.test_module08_blackbox.TestExponentialFormatting.test_float_small_switches_to_exponential", + "eval.tests.test_module08_blackbox.TestHelp.test_h_after_double_short_circuits", + "eval.tests.test_module08_blackbox.TestHelp.test_h_after_int_short_circuits", + "eval.tests.test_module08_blackbox.TestHelp.test_h_prints_usage_and_exits_failure", + "eval.tests.test_module08_blackbox.TestOptionValueConsumption.test_double_consumes_option_token", + "eval.tests.test_module08_blackbox.TestOptionValueConsumption.test_float_consumes_option_token", + "eval.tests.test_module08_blackbox.TestOptionValueConsumption.test_integer_consumes_option_token", + "eval.tests.test_module08_blackbox.TestOptionValueConsumption.test_negative_float", + "eval.tests.test_module08_blackbox.TestRepeatedAndValues.test_negative_integer", + "eval.tests.test_module08_blackbox.TestRepeatedAndValues.test_repeated_float_last_wins", + "eval.tests.test_module08_blackbox.TestRepeatedAndValues.test_repeated_integer_last_wins", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_float_scientific_notation", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_float_truncates_to_output_precision", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_large_integer_value", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_negative_double", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_non_numeric_integer_parses_to_zero", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_scientific_and_plain_float_are_equivalent", + "eval.tests.test_module08_blackbox.TestValueSemantics.test_zero_integer_is_not_default" + ] + } + }, + "commit": "22e3a84e7f1fc8cacda0f6a0843dfad8a2ca6487", + "data_source": "synthetic_programgym", + "difficulty": "hard", + "difficulty_score": 4.686427114155551, + "eval_clean_hashes": [ + "ef83d6873e97427c99808b65ce9d1930ee6642bbc30fb594b0a48ce31865edbe" + ], + "input_record": { + "commit": "22e3a84e7f1fc8cacda0f6a0843dfad8a2ca6487", + "full_name": "lagadic/visp", + "input_joern_zip": "cpp_joern/lagadic__visp.zip", + "joern_status": true, + "joern_time": 114.42528560594656, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "OSGeo/PROJ", + "rank": 931, + "similarity": 0.3869578242301941 + } + ], + "repo_path": "cpp/lagadic__visp", + "source": "commit:22e3a84e7f1fc8cacda0f6a0843dfad8a2ca6487", + "status": "done", + "url": "https://github.com/lagadic/visp" + }, + "instance_id": "lagadic__visp.22e3a84", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 20, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 7, + "branch_name": "generated_module_02", + "iteration_limit": 20, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 20, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 20, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_05", + "iteration_limit": 20, + "module_index": 5, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_06", + "iteration_limit": 20, + "module_index": 6, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 20, + "branch_name": "generated_module_07", + "iteration_limit": 20, + "module_index": 7, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_08", + "iteration_limit": 20, + "module_index": 8, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "lagadic/visp" +} diff --git a/lagadic--visp.22e3a84/tests/test.sh b/lagadic--visp.22e3a84/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/lagadic--visp.22e3a84/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/lagadic--visp.22e3a84/tests/workspace.tar.gz b/lagadic--visp.22e3a84/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..fdeb6468404524be62348b1e21b838408ec509af --- /dev/null +++ b/lagadic--visp.22e3a84/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3f1a317018067cabb15ddb855ac86e868444f9d31b082b8d87a0fbaa9a95003c +size 8138 diff --git a/landlock-lsm--go-landlock.e573f5/environment/Dockerfile b/landlock-lsm--go-landlock.e573f5/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..18c9b14a3dd87ff70c68d67e0e9cd3cb548e1b1a --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/environment/Dockerfile @@ -0,0 +1,60 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/landlock-lsm--go-landlock.e573f5/environment/download.sh b/landlock-lsm--go-landlock.e573f5/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..d71da1b99b3e9f9aafeb7bcb12cad4f22301fa1c --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/environment/download.sh @@ -0,0 +1,157 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/landlock-lsm/go-landlock + +go 1.24.0 + +require ( + golang.org/x/sys v0.40.0 + kernel.org/pub/linux/libs/security/libcap/psx v1.2.77 +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= +golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +kernel.org/pub/linux/libs/security/libcap/psx v1.2.77 h1:Z06sMOzc0GNCwp6efaVrIrz4ywGJ1v+DP0pjVkOfDuA= +kernel.org/pub/linux/libs/security/libcap/psx v1.2.77/go.mod h1:+l6Ee2F59XiJ2I6WR5ObpC1utCQJZ/VLsEbQCD8RG24= +PROGRAMGYM_GO_SUM_EOF +PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY="${GOPROXY:-direct}" +PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="" +case "$PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY" in + *"|"*|*","*) + PROGRAMGYM_INTERNAL_GO_FIRST_PROXY="${PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY%%[,|]*}" + PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER="${PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY#*[,|]}" + if [[ "$PROGRAMGYM_INTERNAL_GO_FIRST_PROXY" =~ [^[:space:]] ]] && [[ "$PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER" =~ [^[:space:]] ]]; then + PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="${PROGRAMGYM_GO_PUBLIC_FALLBACK_PROXY:-${PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER}}" + fi + ;; +esac +if ! [[ "$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" =~ [^[:space:]] ]]; then + PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="" +fi +cat > /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py <<'PROGRAMGYM_GO_TIMEOUT_SUPERVISOR_EOF' +import os +import signal +import subprocess +import sys +import time + +sentinel_path, timeout_text, grace_text, proxy, *command = sys.argv[1:] +if not command: + raise SystemExit(125) +environment = os.environ.copy() +environment["GOPROXY"] = proxy +process = subprocess.Popen(command, env=environment, start_new_session=True) +try: + returncode = process.wait(timeout=float(timeout_text)) +except subprocess.TimeoutExpired: + with open(sentinel_path, "w", encoding="utf-8") as sentinel: + sentinel.write("expired\n") + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + deadline = time.monotonic() + float(grace_text) + group_alive = True + while time.monotonic() < deadline: + process.poll() + try: + os.killpg(process.pid, 0) + except ProcessLookupError: + group_alive = False + break + time.sleep(0.05) + if group_alive: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + raise SystemExit(124) +if returncode < 0: + returncode = 128 - returncode +raise SystemExit(returncode) +PROGRAMGYM_GO_TIMEOUT_SUPERVISOR_EOF +PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS="${PROGRAMGYM_GO_NEXUS_ATTEMPT_TIMEOUT_SECONDS:-90}" +if ! [[ "$PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS" =~ ^[1-9][0-9]*$ ]]; then + printf '%s\n' "download.sh: invalid PROGRAMGYM_GO_NEXUS_ATTEMPT_TIMEOUT_SECONDS=${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}" >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if ! command -v python3 >/dev/null 2>&1; then + printf '%s\n' 'download.sh: python3 is required for bounded Nexus Go downloads' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +_programgym_go_with_nexus_timeout() { + local programgym_go_rc + local programgym_go_timeout_sentinel + if ! programgym_go_timeout_sentinel="$(mktemp "${TMPDIR:-/tmp}/programgym-go-timeout.XXXXXX")"; then + return 1 + fi + if python3 /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py "$programgym_go_timeout_sentinel" "$PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS" "5" "$PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY" "$@"; then + programgym_go_rc=0 + else + programgym_go_rc=$? + fi + if [ ! -s "$programgym_go_timeout_sentinel" ]; then + rm -f "$programgym_go_timeout_sentinel" + return "$programgym_go_rc" + fi + rm -f "$programgym_go_timeout_sentinel" + if [ -z "$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" ]; then + printf '%s\n' "download.sh: primary Go request exceeded ${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}s; GOPROXY has no explicit non-empty fallback remainder" >&2 + return "$programgym_go_rc" + fi + printf '%s\n' "download.sh: Nexus-first Go request exceeded ${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}s; retrying with GOPROXY=${PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY}" >&2 + env GOPROXY="$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" "$@" +} +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && _programgym_go_with_nexus_timeout env GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +if ! (cd /workspace/.programgym_build_env/go-prefetch && _programgym_go_with_nexus_timeout go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py +unset -f _programgym_go_with_nexus_timeout +unset PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY +unset PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY +unset PROGRAMGYM_INTERNAL_GO_FIRST_PROXY +unset PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER +unset PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS diff --git a/landlock-lsm--go-landlock.e573f5/environment/executable b/landlock-lsm--go-landlock.e573f5/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..928cc5320b57feabd615a7ae231149a8359f1e6b --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d1b14db7154ec4721f78db72bfbf9130eaafec8ff88211b2b7e181a58ebad7e +size 2574280 diff --git a/landlock-lsm--go-landlock.e573f5/environment/programgym-go.tar.gz b/landlock-lsm--go-landlock.e573f5/environment/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/environment/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/landlock-lsm--go-landlock.e573f5/environment/workspace.tar.gz b/landlock-lsm--go-landlock.e573f5/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..164cc733f07efdd3126d964ebc341ebe748deb76 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36d9b74ef4396357f9cfced957e3a70acb031951da3c2f521b9906079e7a6d12 +size 1303 diff --git a/landlock-lsm--go-landlock.e573f5/instruction.md b/landlock-lsm--go-landlock.e573f5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/landlock-lsm--go-landlock.e573f5/solution/solve.sh b/landlock-lsm--go-landlock.e573f5/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/landlock-lsm--go-landlock.e573f5/task.toml b/landlock-lsm--go-landlock.e573f5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f8ba9668906c13223d379d8fce00062ae3a4f0b9 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/landlock-lsm--go-landlock.e573f5" +description = "Synthetic ProgramGym cleanroom reconstruction task for landlock-lsm/go-landlock" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "go"] + +[metadata] +source = "ProgramGym" +instance_id = "landlock-lsm__go-landlock.e573f52" +repository = "landlock-lsm/go-landlock" +commit = "e573f52a61e3072813de11359239d2ccae9705d2" +language = "go" +difficulty = "easy" +difficulty_score = 1.8321894610685132 +test_branches = 4 +test_count = 234 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/landlock-lsm--go-landlock.e573f5/tests/Dockerfile b/landlock-lsm--go-landlock.e573f5/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..a626a06f42b7d18ca8dda5f990bed0106ab28bf5 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/Dockerfile @@ -0,0 +1,68 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# programgym-runtime-workspace-cleanup: v1 +RUN ["bash","-lc","rm -f -- /workspace/download.sh /workspace/reference/build.sh && rm -rf -- /workspace/.programgym_build_env"] +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_01.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1f409a3fbc11a74d0fe3476c0cc19f4a0f7766fe --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40c2888698223bc02182ea50883da1f4e7595a62aff9f7444d662a4278899975 +size 7045 diff --git a/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_02.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..79ab5ff5ba48efdac5e08011b30ee5bb50b24af4 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dec3df2a6407a642ca2ece53b02d2c455ff0df422794d17e85c8897525bcafeb +size 5594 diff --git a/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_03.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6d3ee23b88004af5126e9fbed680b1a61fdeedbc --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4942ebc5bef7fdc9d11739c644f4a3190863f59618901da1f3c26939ce4517da +size 11089 diff --git a/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_04.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b236bf1530ae56e45c9abf2b26c6174134f27cb2 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:376fdc04cbc8c6756666bf9649479b05a3a47606640dade95f51cf941028d30c +size 5901 diff --git a/landlock-lsm--go-landlock.e573f5/tests/download.sh b/landlock-lsm--go-landlock.e573f5/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..d71da1b99b3e9f9aafeb7bcb12cad4f22301fa1c --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/download.sh @@ -0,0 +1,157 @@ +#!/usr/bin/env bash +# PROGRAMGYM-MANAGED-GO-DOWNLOAD: v1 +# Generated deterministically from repository module metadata; do not edit. +set -u +export GOTOOLCHAIN=auto +mkdir -p /workspace/.programgym_build_env/go-prefetch +cat > /workspace/.programgym_build_env/go-prefetch/go.mod <<'PROGRAMGYM_GO_MOD_EOF' +module github.com/landlock-lsm/go-landlock + +go 1.24.0 + +require ( + golang.org/x/sys v0.40.0 + kernel.org/pub/linux/libs/security/libcap/psx v1.2.77 +) +PROGRAMGYM_GO_MOD_EOF +cat > /workspace/.programgym_build_env/go-prefetch/go.sum <<'PROGRAMGYM_GO_SUM_EOF' +golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= +golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +kernel.org/pub/linux/libs/security/libcap/psx v1.2.77 h1:Z06sMOzc0GNCwp6efaVrIrz4ywGJ1v+DP0pjVkOfDuA= +kernel.org/pub/linux/libs/security/libcap/psx v1.2.77/go.mod h1:+l6Ee2F59XiJ2I6WR5ObpC1utCQJZ/VLsEbQCD8RG24= +PROGRAMGYM_GO_SUM_EOF +PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY="${GOPROXY:-direct}" +PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="" +case "$PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY" in + *"|"*|*","*) + PROGRAMGYM_INTERNAL_GO_FIRST_PROXY="${PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY%%[,|]*}" + PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER="${PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY#*[,|]}" + if [[ "$PROGRAMGYM_INTERNAL_GO_FIRST_PROXY" =~ [^[:space:]] ]] && [[ "$PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER" =~ [^[:space:]] ]]; then + PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="${PROGRAMGYM_GO_PUBLIC_FALLBACK_PROXY:-${PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER}}" + fi + ;; +esac +if ! [[ "$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" =~ [^[:space:]] ]]; then + PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY="" +fi +cat > /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py <<'PROGRAMGYM_GO_TIMEOUT_SUPERVISOR_EOF' +import os +import signal +import subprocess +import sys +import time + +sentinel_path, timeout_text, grace_text, proxy, *command = sys.argv[1:] +if not command: + raise SystemExit(125) +environment = os.environ.copy() +environment["GOPROXY"] = proxy +process = subprocess.Popen(command, env=environment, start_new_session=True) +try: + returncode = process.wait(timeout=float(timeout_text)) +except subprocess.TimeoutExpired: + with open(sentinel_path, "w", encoding="utf-8") as sentinel: + sentinel.write("expired\n") + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + deadline = time.monotonic() + float(grace_text) + group_alive = True + while time.monotonic() < deadline: + process.poll() + try: + os.killpg(process.pid, 0) + except ProcessLookupError: + group_alive = False + break + time.sleep(0.05) + if group_alive: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + raise SystemExit(124) +if returncode < 0: + returncode = 128 - returncode +raise SystemExit(returncode) +PROGRAMGYM_GO_TIMEOUT_SUPERVISOR_EOF +PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS="${PROGRAMGYM_GO_NEXUS_ATTEMPT_TIMEOUT_SECONDS:-90}" +if ! [[ "$PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS" =~ ^[1-9][0-9]*$ ]]; then + printf '%s\n' "download.sh: invalid PROGRAMGYM_GO_NEXUS_ATTEMPT_TIMEOUT_SECONDS=${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}" >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if ! command -v python3 >/dev/null 2>&1; then + printf '%s\n' 'download.sh: python3 is required for bounded Nexus Go downloads' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +_programgym_go_with_nexus_timeout() { + local programgym_go_rc + local programgym_go_timeout_sentinel + if ! programgym_go_timeout_sentinel="$(mktemp "${TMPDIR:-/tmp}/programgym-go-timeout.XXXXXX")"; then + return 1 + fi + if python3 /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py "$programgym_go_timeout_sentinel" "$PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS" "5" "$PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY" "$@"; then + programgym_go_rc=0 + else + programgym_go_rc=$? + fi + if [ ! -s "$programgym_go_timeout_sentinel" ]; then + rm -f "$programgym_go_timeout_sentinel" + return "$programgym_go_rc" + fi + rm -f "$programgym_go_timeout_sentinel" + if [ -z "$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" ]; then + printf '%s\n' "download.sh: primary Go request exceeded ${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}s; GOPROXY has no explicit non-empty fallback remainder" >&2 + return "$programgym_go_rc" + fi + printf '%s\n' "download.sh: Nexus-first Go request exceeded ${PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS}s; retrying with GOPROXY=${PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY}" >&2 + env GOPROXY="$PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY" "$@" +} +PROGRAMGYM_GO_BASE_GOROOT="$(GOTOOLCHAIN=local go env GOROOT)" +if ! PROGRAMGYM_GO_RESOLVED_GOROOT="$(cd /workspace/.programgym_build_env/go-prefetch && _programgym_go_with_nexus_timeout env GOTOOLCHAIN=auto go env GOROOT)"; then + printf '%s\n' 'download.sh: Go toolchain resolution failed' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +if [ "$PROGRAMGYM_GO_RESOLVED_GOROOT" != "$PROGRAMGYM_GO_BASE_GOROOT" ]; then + PROGRAMGYM_GO_TOOLCHAIN_ROOT=/opt/programgym-go-toolchain + mkdir -p "$PROGRAMGYM_GO_TOOLCHAIN_ROOT" + cp -a "$PROGRAMGYM_GO_RESOLVED_GOROOT/." "$PROGRAMGYM_GO_TOOLCHAIN_ROOT/" + export GOROOT="$PROGRAMGYM_GO_TOOLCHAIN_ROOT" +else + export GOROOT="$PROGRAMGYM_GO_BASE_GOROOT" +fi +export PATH="$GOROOT/bin:$PATH" +export GOTOOLCHAIN=local +if ! (cd /workspace/.programgym_build_env/go-prefetch && _programgym_go_with_nexus_timeout go mod download -modfile=/workspace/.programgym_build_env/go-prefetch/go.mod all); then + printf '%s\n' 'download.sh: Go dependency prefetch failed' >&2 + rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +fi +rm -f /workspace/.programgym_build_env/go-prefetch/.programgym_go_timeout_supervisor.py +unset -f _programgym_go_with_nexus_timeout +unset PROGRAMGYM_INTERNAL_GO_PRIMARY_PROXY +unset PROGRAMGYM_INTERNAL_GO_FALLBACK_PROXY +unset PROGRAMGYM_INTERNAL_GO_FIRST_PROXY +unset PROGRAMGYM_INTERNAL_GO_PROXY_REMAINDER +unset PROGRAMGYM_INTERNAL_GO_NEXUS_TIMEOUT_SECONDS diff --git a/landlock-lsm--go-landlock.e573f5/tests/executable b/landlock-lsm--go-landlock.e573f5/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..928cc5320b57feabd615a7ae231149a8359f1e6b --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d1b14db7154ec4721f78db72bfbf9130eaafec8ff88211b2b7e181a58ebad7e +size 2574280 diff --git a/landlock-lsm--go-landlock.e573f5/tests/programgym-go.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/programgym-go.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0532cfb0397c6d86ac290d2a8c6843ef8e985e31 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/programgym-go.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39042a078ea9ceebe3ecda4a7188f0f5b96e14a071d27923ba7f40b456e85ae3 +size 59908810 diff --git a/landlock-lsm--go-landlock.e573f5/tests/programgym_evaluator.py b/landlock-lsm--go-landlock.e573f5/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/landlock-lsm--go-landlock.e573f5/tests/programgym_task.json b/landlock-lsm--go-landlock.e573f5/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..9843f566f828a74f8cc32665c0ae0aaec089e19e --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/programgym_task.json @@ -0,0 +1,360 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_config_args.test_absolute_exec_path_after_dashdash_accepted", + "eval.tests.test_config_args.test_bare_positional_without_dashdash_is_unrecognized", + "eval.tests.test_config_args.test_missing_command_prints_usage_and_fails", + "eval.tests.test_config_args.test_relative_exec_path_rejected", + "eval.tests.test_config_args.test_relative_exec_path_rejected_dot", + "eval.tests.test_config_args.test_single_dash_expected_command_but_blank_fails", + "eval.tests.test_config_args.test_unknown_long_option_fails", + "eval.tests.test_config_args.test_unknown_option_fails", + "eval.tests.test_config_args.test_usage_stderr_contains_usage_hint", + "eval.tests.test_config_args.test_version_and_command_after_dashdash", + "eval.tests.test_config_downgrade.test_best_effort_default", + "eval.tests.test_config_downgrade.test_best_effort_v1_succeeds", + "eval.tests.test_config_downgrade.test_best_effort_v9_succeeds_through_downgrade", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v2_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v3_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v4_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v5_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v6_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v7_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v8_fails]", + "eval.tests.test_config_downgrade.test_strict_unsupported_version_fails_with_exact_message[strict_v9_fails]", + "eval.tests.test_config_downgrade.test_strict_v1_succeeds", + "eval.tests.test_config_downgrade.test_strict_v9_fails_with_kernel_error", + "eval.tests.test_config_downgrade.test_strict_versus_best_effort_v9_contrast", + "eval.tests.test_config_string.test_args_log_line_echoes_argv", + "eval.tests.test_config_string.test_config_string_abi_selection[v-1__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-1__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-1__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-1__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-2__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-2__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-2__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-2__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-3__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-3__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-3__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-3__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-4__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-4__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-4__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-4__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-5__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-5__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-5__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-5__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-6__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-6__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-6__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-6__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-7__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-7__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-7__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-7__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-8__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-8__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-8__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-8__strict__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-9__best-effort]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-9__best-effort__log]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-9__strict]", + "eval.tests.test_config_string.test_config_string_abi_selection[v-9__strict__log]", + "eval.tests.test_config_string.test_fs_access_set_rendered_explicitly_at_low_abi", + "eval.tests.test_config_string.test_fs_only_versions_have_empty_net_scoped", + "eval.tests.test_config_string.test_last_version_flag_wins", + "eval.tests.test_config_string.test_log_flag_adds_flag_suffix", + "eval.tests.test_config_string.test_log_flag_on_lower_version_bumps_to_v7", + "eval.tests.test_config_string.test_log_flag_on_v9_keeps_v9_label", + "eval.tests.test_config_string.test_programgym_executable_environment", + "eval.tests.test_config_string.test_strict_removes_best_effort_suffix", + "eval.tests.test_config_string.test_v7_v8_presets_report_v6", + "eval.tests.test_config_string.test_version_flag_then_strict_reset" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_accessfs_module.test_all_three_modifiers_combined_on_rw", + "eval.tests.test_accessfs_module.test_base_rule_access_set_rendering[ro-read-only-dirs]", + "eval.tests.test_accessfs_module.test_base_rule_access_set_rendering[rofiles-read-only-files]", + "eval.tests.test_accessfs_module.test_base_rule_access_set_rendering[rw-read-write-dirs]", + "eval.tests.test_accessfs_module.test_base_rule_access_set_rendering[rwfiles-read-write-files]", + "eval.tests.test_accessfs_module.test_ioctl_dev_added_to_read_write_dirs", + "eval.tests.test_accessfs_module.test_ioctl_dev_and_resolve_unix_not_rejected_by_module_at_v1", + "eval.tests.test_accessfs_module.test_missing_command_shows_usage_and_fails", + "eval.tests.test_accessfs_module.test_missing_command_with_path_option_still_fails", + "eval.tests.test_accessfs_module.test_mixed_ro_and_rw_rules", + "eval.tests.test_accessfs_module.test_modifier_applies_only_to_its_own_rule", + "eval.tests.test_accessfs_module.test_modifier_order_does_not_matter", + "eval.tests.test_accessfs_module.test_multiple_paths_rendering", + "eval.tests.test_accessfs_module.test_multiple_ro_rules_each_rendered", + "eval.tests.test_accessfs_module.test_path_option_prefixed_lines[-ro-{execute,read_file,read_dir}]", + "eval.tests.test_accessfs_module.test_path_option_prefixed_lines[-rofiles-{execute,read_file}]", + "eval.tests.test_accessfs_module.test_path_option_prefixed_lines[-rw-{execute,write_file,read_file,read_dir,remove_dir,remove_file,make_char,make_dir,make_reg,make_sock,make_fifo,make_block,make_sym,truncate}]", + "eval.tests.test_accessfs_module.test_path_option_prefixed_lines[-rwfiles-{execute,write_file,read_file,truncate}]", + "eval.tests.test_accessfs_module.test_refer_added_to_read_only_dirs", + "eval.tests.test_accessfs_module.test_refer_and_resolve_unix_combined", + "eval.tests.test_accessfs_module.test_relative_command_rejected", + "eval.tests.test_accessfs_module.test_repeated_path_rights_not_deduplicated", + "eval.tests.test_accessfs_module.test_resolve_unix_added_to_read_write_files", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-ro-{execute,read_file,read_dir}-+ioctl_dev-ioctl_dev]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-ro-{execute,read_file,read_dir}-+refer-refer]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-ro-{execute,read_file,read_dir}-+resolve_unix-resolve_unix]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rofiles-{execute,read_file}-+ioctl_dev-ioctl_dev]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rofiles-{execute,read_file}-+refer-refer]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rofiles-{execute,read_file}-+resolve_unix-resolve_unix]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rw-{execute,write_file,read_file,read_dir,remove_dir,remove_file,make_char,make_dir,make_reg,make_sock,make_fifo,make_block,make_sym,truncate}-+ioctl_dev-ioctl_dev]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rw-{execute,write_file,read_file,read_dir,remove_dir,remove_file,make_char,make_dir,make_reg,make_sock,make_fifo,make_block,make_sym,truncate}-+refer-refer]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rw-{execute,write_file,read_file,read_dir,remove_dir,remove_file,make_char,make_dir,make_reg,make_sock,make_fifo,make_block,make_sym,truncate}-+resolve_unix-resolve_unix]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rwfiles-{execute,write_file,read_file,truncate}-+ioctl_dev-ioctl_dev]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rwfiles-{execute,write_file,read_file,truncate}-+refer-refer]", + "eval.tests.test_accessfs_module.test_single_modifier_adds_exact_right[-rwfiles-{execute,write_file,read_file,truncate}-+resolve_unix-resolve_unix]", + "eval.tests.test_accessfs_module.test_single_path_rendering", + "eval.tests.test_accessfs_module.test_unrecognized_flag_short_option_rejected", + "eval.tests.test_accessfs_module.test_unrecognized_option_rejected", + "eval.tests.test_accessfs_module.test_v1_best_effort_refer_rule_incompatible", + "eval.tests.test_accessfs_module.test_v1_read_only_rule_ok", + "eval.tests.test_accessfs_module.test_v1_strict_refer_rule_incompatible", + "eval.tests.test_accessfs_module.test_v2_strict_refer_no_compatibility_error" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli.test_all_version_flags_parse[-1]", + "eval.tests.test_cli.test_all_version_flags_parse[-2]", + "eval.tests.test_cli.test_all_version_flags_parse[-3]", + "eval.tests.test_cli.test_all_version_flags_parse[-4]", + "eval.tests.test_cli.test_all_version_flags_parse[-5]", + "eval.tests.test_cli.test_all_version_flags_parse[-6]", + "eval.tests.test_cli.test_all_version_flags_parse[-7]", + "eval.tests.test_cli.test_all_version_flags_parse[-8]", + "eval.tests.test_cli.test_all_version_flags_parse[-9]", + "eval.tests.test_cli.test_missing_command_after_flags", + "eval.tests.test_cli.test_no_args_prints_usage", + "eval.tests.test_cli.test_relative_command_path_rejected", + "eval.tests.test_cli.test_unrecognized_option_rejected", + "eval.tests.test_cli.test_verbose_best_effort_v9_config_line", + "eval.tests.test_cli.test_verbose_executing_command_line", + "eval.tests.test_cli.test_verbose_logging_flag_config_line", + "eval.tests.test_cli.test_verbose_path_option_reveals_refer_extra", + "eval.tests.test_cli.test_verbose_path_option_reveals_ro_access", + "eval.tests.test_cli.test_verbose_strict_v1_config_line", + "eval.tests.test_cli.test_version_flag_zero_rejected", + "eval.tests.test_regression.test_best_effort_is_deterministic", + "eval.tests.test_regression.test_command_with_arguments_passed_through", + "eval.tests.test_regression.test_long_path_hierarchy_rule", + "eval.tests.test_regression.test_rofiles_refer_parses", + "eval.tests.test_regression.test_strict_error_wanted_config_is_fsonly", + "eval.tests.test_regression.test_verbose_strict_v9_pretestriction_config", + "eval.tests.test_restrict.test_best_effort_drops_unsupported_extras[flags0-ro_dir_refer-cmd0-refer-ok]", + "eval.tests.test_restrict.test_best_effort_drops_unsupported_extras[flags1-rw_dir_ioctl-cmd1-ioctl-ok]", + "eval.tests.test_restrict.test_best_effort_drops_unsupported_extras[flags2-rw_dir_resolve-cmd2-resolve-ok]", + "eval.tests.test_restrict.test_best_effort_drops_unsupported_extras[flags3-rw_dir_ioctl_resolve-cmd3-iores-ok]", + "eval.tests.test_restrict.test_best_effort_multiple_path_options", + "eval.tests.test_restrict.test_best_effort_restrict_and_exec_succeeds[flags0-ro_dir_echo-cmd0-hello-ro]", + "eval.tests.test_restrict.test_best_effort_restrict_and_exec_succeeds[flags1-rw_dir_echo-cmd1-hello-rw]", + "eval.tests.test_restrict.test_best_effort_restrict_and_exec_succeeds[flags2-ro_file_echo-cmd2-hello-files]", + "eval.tests.test_restrict.test_best_effort_restrict_and_exec_succeeds[flags3-rw_file_echo-cmd3-hello-rwfiles]", + "eval.tests.test_restrict.test_best_effort_whole_root_readonly", + "eval.tests.test_restrict.test_exec_denied_when_command_outside_allowed", + "eval.tests.test_restrict.test_invalid_file_missing_create_fails", + "eval.tests.test_restrict.test_invalid_path_populating_ruleset_error[-ro-{execute,read_file,read_dir}]", + "eval.tests.test_restrict.test_invalid_path_populating_ruleset_error[-rw-{execute,write_file,read_file,read_dir,remove_dir,remove_file,make_char,make_dir,make_reg,make_sock,make_fifo,make_block,make_sym}]", + "eval.tests.test_restrict.test_read_file_inside_allowed", + "eval.tests.test_restrict.test_read_file_outside_denied", + "eval.tests.test_restrict.test_read_opened_before_but_denied_path_resolved", + "eval.tests.test_restrict.test_strict_abi1_supported_succeeds", + "eval.tests.test_restrict.test_strict_unsupported_extras_error", + "eval.tests.test_restrict.test_strict_unsupported_version_errors", + "eval.tests.test_restrict.test_strict_v9_errors_on_low_abi", + "eval.tests.test_restrict.test_write_file_inside_allowed", + "eval.tests.test_restrict.test_write_file_outside_denied", + "eval.tests.test_ruleset.test_dir_rule_on_missing_file_reports_open_error", + "eval.tests.test_ruleset.test_dir_rule_on_regular_file_rejected", + "eval.tests.test_ruleset.test_duplicate_ro_rules_are_idempotent", + "eval.tests.test_ruleset.test_list_directory_inside_allowed", + "eval.tests.test_ruleset.test_list_directory_outside_denied", + "eval.tests.test_ruleset.test_ro_and_rw_on_same_dir", + "eval.tests.test_ruleset.test_rofiles_read_existing_file", + "eval.tests.test_ruleset.test_rwfiles_append_existing_file", + "eval.tests.test_ruleset.test_two_distinct_ro_rules", + "eval.tests.test_upgrade_fallback.test_best_effort_ioctl_def_keeps_enforcement", + "eval.tests.test_upgrade_fallback.test_best_effort_refer_forces_v0_no_restriction", + "eval.tests.test_upgrade_fallback.test_best_effort_resolve_unix_keeps_enforcement", + "eval.tests.test_upgrade_fallback.test_best_effort_ro_without_refer_is_enforced", + "eval.tests.test_upgrade_fallback.test_best_effort_rw_refer_forces_v0_no_restriction", + "eval.tests.test_upgrade_fallback.test_strict_v1_incompatible_refer_rule_error", + "eval.tests.test_upgrade_fallback.test_strict_v1_without_refer_not_incompatible" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli_args.test_absolute_command_path_accepted[/]", + "eval.tests.test_cli_args.test_absolute_command_path_accepted[/bin/echo]", + "eval.tests.test_cli_args.test_absolute_command_path_accepted[/usr/bin/date]", + "eval.tests.test_cli_args.test_default_config_is_v9_best_effort", + "eval.tests.test_cli_args.test_double_dash_begins_command", + "eval.tests.test_cli_args.test_early_version_flags_select_version[-1-Landlock V1]", + "eval.tests.test_cli_args.test_early_version_flags_select_version[-2-Landlock V2]", + "eval.tests.test_cli_args.test_early_version_flags_select_version[-3-Landlock V3]", + "eval.tests.test_cli_args.test_high_version_flags_accepted_and_downgrade[-6]", + "eval.tests.test_cli_args.test_high_version_flags_accepted_and_downgrade[-7]", + "eval.tests.test_cli_args.test_high_version_flags_accepted_and_downgrade[-8]", + "eval.tests.test_cli_args.test_logging_flag_sets_log_new_exec", + "eval.tests.test_cli_args.test_multiple_version_flags_last_wins", + "eval.tests.test_cli_args.test_non_missing_absolute_command_path_rejected[..]", + "eval.tests.test_cli_args.test_non_missing_absolute_command_path_rejected[./prog]", + "eval.tests.test_cli_args.test_non_missing_absolute_command_path_rejected[bin/echo]", + "eval.tests.test_cli_args.test_non_missing_absolute_command_path_rejected[no-slash-binary]", + "eval.tests.test_cli_args.test_non_missing_absolute_command_path_rejected[usr/bin/date]", + "eval.tests.test_cli_args.test_strict_removes_best_effort", + "eval.tests.test_cli_args.test_verbose_preamble_without_command", + "eval.tests.test_cli_args.test_version_flags_set_reported_level[-4-Landlock V4]", + "eval.tests.test_cli_args.test_version_flags_set_reported_level[-5-Landlock V5]", + "eval.tests.test_cli_args.test_version_flags_set_reported_level[-6-Landlock V6]", + "eval.tests.test_cli_args.test_version_flags_set_reported_level[-9-Landlock V9]", + "eval.tests.test_cli_usage.test_flags_without_command_still_print_usage", + "eval.tests.test_cli_usage.test_no_command_prints_usage_and_exits_nonzero", + "eval.tests.test_cli_usage.test_unknown_option_reports_unrecognized", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[--h]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[--help]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-h]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-help]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-rofile]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-rwd]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-x]", + "eval.tests.test_cli_usage.test_unrecognized_option_variants[-zz]", + "eval.tests.test_cli_usage.test_usage_avoids_verbose_preamble", + "eval.tests.test_exec.test_command_with_only_relative_cmd_never_reaches_exec", + "eval.tests.test_exec.test_exec_error_branch_for_real_absolute_command[/bin/date]", + "eval.tests.test_exec.test_exec_error_branch_for_real_absolute_command[/bin/echo]", + "eval.tests.test_exec.test_exec_error_branch_for_real_absolute_command[/bin/true]", + "eval.tests.test_exec.test_exec_error_branch_for_real_absolute_command[/usr/bin/printf]", + "eval.tests.test_exec.test_nonexistent_restricted_path_fails_rule_population", + "eval.tests.test_exec.test_restrictpaths_error_branch_under_strict", + "eval.tests.test_exec.test_verbose_reports_command_before_exec", + "eval.tests.test_path_options.test_combined_modifiers_accumulate", + "eval.tests.test_path_options.test_empty_path_list_produces_empty_rule", + "eval.tests.test_path_options.test_ioctl_dev_modifier", + "eval.tests.test_path_options.test_multiple_option_groups_build_distinct_rules", + "eval.tests.test_path_options.test_multiple_paths_accumulate_in_one_rule", + "eval.tests.test_path_options.test_refer_modifier_adds_refer_right", + "eval.tests.test_path_options.test_resolve_unix_modifier", + "eval.tests.test_path_options.test_ro_read_only_dirs", + "eval.tests.test_path_options.test_rofiles_read_only_files", + "eval.tests.test_path_options.test_rw_read_write_dirs", + "eval.tests.test_path_options.test_rwfiles_read_write_files", + "eval.tests.test_path_options.test_trailing_non_modifier_tokens_are_paths" + ] + } + }, + "commit": "e573f52a61e3072813de11359239d2ccae9705d2", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.8321894610685132, + "eval_clean_hashes": [ + "0d1b14db7154ec4721f78db72bfbf9130eaafec8ff88211b2b7e181a58ebad7e" + ], + "input_record": { + "commit": "e573f52a61e3072813de11359239d2ccae9705d2", + "commits": 247, + "contributors": 7, + "difficulty": "easy", + "difficulty_code_lines": 2265, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 2265, + "difficulty_runtime_deps": 2, + "difficulty_score": 1.8321894610685132, + "difficulty_test_code_lines": 1882, + "full_name": "landlock-lsm/go-landlock", + "github_stars": 342, + "input_joern_zip": "go_joern/landlock-lsm__go-landlock.zip", + "joern_status": true, + "joern_time": 7.092235384043306, + "language": "go", + "pb_match": [ + { + "pb_fullname": "go-critic/go-critic", + "rank": 732, + "similarity": 0.5156829357147217 + }, + { + "pb_fullname": "direnv/direnv", + "rank": 101, + "similarity": 0.4744473099708557 + }, + { + "pb_fullname": "mgechev/revive", + "rank": 591, + "similarity": 0.5307084918022156 + }, + { + "pb_fullname": "kisielk/errcheck", + "rank": 503, + "similarity": 0.5550646781921387 + }, + { + "pb_fullname": "tomarrell/wrapcheck", + "rank": 282, + "similarity": 0.5364243984222412 + } + ], + "repo_age": 5.1, + "repo_path": "go/landlock-lsm__go-landlock", + "source": "commit:e573f52a61e3072813de11359239d2ccae9705d2", + "status": "done", + "url": "https://github.com/landlock-lsm/go-landlock" + }, + "instance_id": "landlock-lsm__go-landlock.e573f52", + "language": "go", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "landlock-lsm/go-landlock" +} diff --git a/landlock-lsm--go-landlock.e573f5/tests/test.sh b/landlock-lsm--go-landlock.e573f5/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/landlock-lsm--go-landlock.e573f5/tests/workspace.tar.gz b/landlock-lsm--go-landlock.e573f5/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..164cc733f07efdd3126d964ebc341ebe748deb76 --- /dev/null +++ b/landlock-lsm--go-landlock.e573f5/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36d9b74ef4396357f9cfced957e3a70acb031951da3c2f521b9906079e7a6d12 +size 1303 diff --git a/lava--matplotlib-cpp.ef0383f/environment/Dockerfile b/lava--matplotlib-cpp.ef0383f/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..cd042aa1c8902da43f5e168d272841107895d27b --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/lava--matplotlib-cpp.ef0383f/environment/docker-compose.yaml b/lava--matplotlib-cpp.ef0383f/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lava--matplotlib-cpp.ef0383f/environment/download.sh b/lava--matplotlib-cpp.ef0383f/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..27f60679d9413c7c4d3881cfde82ef82dd9611f0 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/download.sh @@ -0,0 +1,65 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym networked download stage for lava/matplotlib-cpp. +# +# Executed via `source /source_ro/download.sh` (not `bash download.sh`), so this +# script must be source-safe: keep exported vars in the current shell, take no +# positional arguments, and never `exit` in normal control flow. +# +# Scope: it ONLY prepares dependencies for the later offline build stage. It does +# NOT compile, link, test, or otherwise build the project. +# +# For the selected `minimal` example executable, the repository's CMakeLists.txt +# requires: +# - Python3::NumPy (compile-time: find_package(Python3 COMPONENTS NumPy) must +# resolve, which needs the numpy module importable with its +# C headers under the python include dir) +# - Python3::Module / Python3::Python (provided by the base image python3-dev) +# - matplotlib runtime module (used by the example backend at runtime) +# +# We satisfy the numpy/matplotlib needs via apt packages (python3-numpy, +# python3-matplotlib). No repository file is read and no build step is performed. +# +# Standalone: all dependency info is explicit and inline. Idempotent: if the +# packages are already present, apt-get reports them and the script is a no-op. + +set -u + +# --------------------------------------------------------------------------- +# Guard: must be sourced, not executed directly. +# --------------------------------------------------------------------------- +if [ "${BASH_SOURCE[0]}" = "$0" ]; then + echo "download.sh must be sourced, not executed directly" 1>&2 + exit 1 +fi + +# --------------------------------------------------------------------------- +# The default python interpreter that build.sh will rely on. +# --------------------------------------------------------------------------- +export PYTHON3_EXECUTABLE="/usr/bin/python3" + +# --------------------------------------------------------------------------- +# numpy + matplotlib are provided by apt packages. Refresh apt indices first so +# the proxy's package lists are present, then install the packages. +# --------------------------------------------------------------------------- +echo "download: refreshing apt package indices" +apt-get update + +echo "download: installing python3-numpy and python3-matplotlib via apt" +apt-get install -y python3-numpy python3-matplotlib + +# --------------------------------------------------------------------------- +# Verify the python-side dependency the CMake configuration will consume. +# --------------------------------------------------------------------------- +if /usr/bin/python3 -c "import numpy"; then + echo "download: numpy available: $(/usr/bin/python3 -c 'import numpy; print(numpy.__version__)')" +else + echo "download: WARNING numpy failed to import" 1>&2 +fi + +if /usr/bin/python3 -c "import matplotlib"; then + echo "download: matplotlib available: $(/usr/bin/python3 -c 'import matplotlib; print(matplotlib.__version__)')" +else + echo "download: WARNING matplotlib failed to import" 1>&2 +fi + +echo "download: dependency preparation complete" diff --git a/lava--matplotlib-cpp.ef0383f/environment/executable b/lava--matplotlib-cpp.ef0383f/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..90ea0afd6e45beb11d8b0255904aa561720583c6 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:641ae68df1cea22fa336f85c973f8eeea6392074968d190bd4e3d9129d88de15 +size 2703136 diff --git a/lava--matplotlib-cpp.ef0383f/environment/harbor_configure_apt_mirror.sh b/lava--matplotlib-cpp.ef0383f/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lava--matplotlib-cpp.ef0383f/environment/harbor_prepare_download_env.sh b/lava--matplotlib-cpp.ef0383f/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lava--matplotlib-cpp.ef0383f/environment/workspace.tar.gz b/lava--matplotlib-cpp.ef0383f/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b2ad7d16ece023434782952884d587c76b66c273 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:020f0066d02e64ca124eebcb947333ff53696d0a71d715a05377bcfafde597ef +size 23338 diff --git a/lava--matplotlib-cpp.ef0383f/instruction.md b/lava--matplotlib-cpp.ef0383f/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/lava--matplotlib-cpp.ef0383f/solution/solve.sh b/lava--matplotlib-cpp.ef0383f/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/lava--matplotlib-cpp.ef0383f/task.toml b/lava--matplotlib-cpp.ef0383f/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..710a3c23e087d02b967dc6d4ae742c86c78d4b8b --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/lava--matplotlib-cpp.ef0383f" +description = "Synthetic ProgramGym cleanroom reconstruction task for lava/matplotlib-cpp" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "lava__matplotlib-cpp.ef0383f" +repository = "lava/matplotlib-cpp" +commit = "ef0383f1315d32e0156335e10b82e90b334f6d9f" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.7761197990529878 +test_branches = 1 +test_count = 15 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/lava--matplotlib-cpp.ef0383f/tests/Dockerfile b/lava--matplotlib-cpp.ef0383f/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ae6071510c9375ad35caf40d5f0fc02507509a77 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/lava--matplotlib-cpp.ef0383f/tests/blobs/tests/generated_module_01.tar.gz b/lava--matplotlib-cpp.ef0383f/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9a7929bcd2f0b88b0f1515518ea0b43092e012e7 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f2c691013b53746afacb8f0935f1dcfe708573e6d4874e72f48e0ae719f7f41 +size 14982907 diff --git a/lava--matplotlib-cpp.ef0383f/tests/docker-compose.yaml b/lava--matplotlib-cpp.ef0383f/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lava--matplotlib-cpp.ef0383f/tests/download.sh b/lava--matplotlib-cpp.ef0383f/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..27f60679d9413c7c4d3881cfde82ef82dd9611f0 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/download.sh @@ -0,0 +1,65 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym networked download stage for lava/matplotlib-cpp. +# +# Executed via `source /source_ro/download.sh` (not `bash download.sh`), so this +# script must be source-safe: keep exported vars in the current shell, take no +# positional arguments, and never `exit` in normal control flow. +# +# Scope: it ONLY prepares dependencies for the later offline build stage. It does +# NOT compile, link, test, or otherwise build the project. +# +# For the selected `minimal` example executable, the repository's CMakeLists.txt +# requires: +# - Python3::NumPy (compile-time: find_package(Python3 COMPONENTS NumPy) must +# resolve, which needs the numpy module importable with its +# C headers under the python include dir) +# - Python3::Module / Python3::Python (provided by the base image python3-dev) +# - matplotlib runtime module (used by the example backend at runtime) +# +# We satisfy the numpy/matplotlib needs via apt packages (python3-numpy, +# python3-matplotlib). No repository file is read and no build step is performed. +# +# Standalone: all dependency info is explicit and inline. Idempotent: if the +# packages are already present, apt-get reports them and the script is a no-op. + +set -u + +# --------------------------------------------------------------------------- +# Guard: must be sourced, not executed directly. +# --------------------------------------------------------------------------- +if [ "${BASH_SOURCE[0]}" = "$0" ]; then + echo "download.sh must be sourced, not executed directly" 1>&2 + exit 1 +fi + +# --------------------------------------------------------------------------- +# The default python interpreter that build.sh will rely on. +# --------------------------------------------------------------------------- +export PYTHON3_EXECUTABLE="/usr/bin/python3" + +# --------------------------------------------------------------------------- +# numpy + matplotlib are provided by apt packages. Refresh apt indices first so +# the proxy's package lists are present, then install the packages. +# --------------------------------------------------------------------------- +echo "download: refreshing apt package indices" +apt-get update + +echo "download: installing python3-numpy and python3-matplotlib via apt" +apt-get install -y python3-numpy python3-matplotlib + +# --------------------------------------------------------------------------- +# Verify the python-side dependency the CMake configuration will consume. +# --------------------------------------------------------------------------- +if /usr/bin/python3 -c "import numpy"; then + echo "download: numpy available: $(/usr/bin/python3 -c 'import numpy; print(numpy.__version__)')" +else + echo "download: WARNING numpy failed to import" 1>&2 +fi + +if /usr/bin/python3 -c "import matplotlib"; then + echo "download: matplotlib available: $(/usr/bin/python3 -c 'import matplotlib; print(matplotlib.__version__)')" +else + echo "download: WARNING matplotlib failed to import" 1>&2 +fi + +echo "download: dependency preparation complete" diff --git a/lava--matplotlib-cpp.ef0383f/tests/executable b/lava--matplotlib-cpp.ef0383f/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..90ea0afd6e45beb11d8b0255904aa561720583c6 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:641ae68df1cea22fa336f85c973f8eeea6392074968d190bd4e3d9129d88de15 +size 2703136 diff --git a/lava--matplotlib-cpp.ef0383f/tests/harbor_configure_apt_mirror.sh b/lava--matplotlib-cpp.ef0383f/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lava--matplotlib-cpp.ef0383f/tests/harbor_prepare_download_env.sh b/lava--matplotlib-cpp.ef0383f/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lava--matplotlib-cpp.ef0383f/tests/programgym_evaluator.py b/lava--matplotlib-cpp.ef0383f/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/lava--matplotlib-cpp.ef0383f/tests/programgym_task.json b/lava--matplotlib-cpp.ef0383f/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..d1e08d15b8ba3f009b7cee18c0625ba42e481701 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/programgym_task.json @@ -0,0 +1,1131 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_backend_errors.test_cairo_backend_aborts_with_pyplot_throw", + "reasons": [ + { + "detail": "AssertionError: cairo missing pyplot throw in: 'Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_cairo_backend_full_stderr_golden", + "reasons": [ + { + "detail": "AssertionError: cairo stderr diverged from golden --- expected --- terminate called after throwing an instance of 'std::runtime_error' what(): Error loading module matplotlib.pyplot! --- actual --- Tr", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_backend_errors.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[DefinitelyNotABackend]", + "reasons": [ + { + "detail": "AssertionError: backend=DefinitelyNotABackend: expected line \"ValueError: Key backend: 'definitelynotabackend' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_1]", + "reasons": [ + { + "detail": "AssertionError: backend=FakeBackend_1: expected line \"ValueError: Key backend: 'fakebackend_1' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'fakeb", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_2]", + "reasons": [ + { + "detail": "AssertionError: backend=FakeBackend_2: expected line \"ValueError: Key backend: 'fakebackend_2' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'fakeb", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_3]", + "reasons": [ + { + "detail": "AssertionError: backend=FakeBackend_3: expected line \"ValueError: Key backend: 'fakebackend_3' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'fakeb", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[NoSuchBackend]", + "reasons": [ + { + "detail": "AssertionError: backend=NoSuchBackend: expected line \"ValueError: Key backend: 'nosuchbackend' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'nosuc", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[NotARealBackend]", + "reasons": [ + { + "detail": "AssertionError: backend=NotARealBackend: expected line \"ValueError: Key backend: 'notarealbackend' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[SomeGUIbackend]", + "reasons": [ + { + "detail": "AssertionError: backend=SomeGUIbackend: expected line \"ValueError: Key backend: 'someguibackend' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'som", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[WebAggMissingPorts]", + "reasons": [ + { + "detail": "AssertionError: backend=WebAggMissingPorts: expected line \"ValueError: Key backend: 'webaggmissingports' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backe", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[my_custom_backend]", + "reasons": [ + { + "detail": "AssertionError: backend=my_custom_backend: expected line \"ValueError: Key backend: 'my_custom_backend' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[qt5agg_typo]", + "reasons": [ + { + "detail": "AssertionError: backend=qt5agg_typo: expected line \"ValueError: Key backend: 'qt5agg_typo' is not a valid value for backend; supported values are\" in stderr assert \"ValueError: Key backend: 'qt5agg_ty", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_invalid_backend_matches_exact_stderr_golden", + "reasons": [ + { + "detail": "AssertionError: stderr diverged from golden --- expected --- Traceback (most recent call last): File \"/usr/lib/python3/dist-packages/matplotlib/__init__.py\", line 1163, in <module> rcParams['backend']", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_backend_errors.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_pylab_import_failure_aborts_with_pylab_throw", + "reasons": [ + { + "detail": "AssertionError: pylab throw missing in: 'Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_backend_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backend_errors.test_pylab_import_failure_full_stderr_golden", + "reasons": [ + { + "detail": "AssertionError: pylab stderr diverged from golden --- expected --- terminate called after throwing an instance of 'std::runtime_error' what(): Error loading module pylab! --- actual --- Traceback (mos", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_backend_errors.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_all_valid_backends_pass_unique_config_dirs", + "reasons": [ + { + "detail": "AssertionError: backend=agg rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[Agg]", + "reasons": [ + { + "detail": "AssertionError: backend=Agg: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[PDF]", + "reasons": [ + { + "detail": "AssertionError: backend=PDF: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[Svg]", + "reasons": [ + { + "detail": "AssertionError: backend=Svg: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_default_backend_when_unset", + "reasons": [ + { + "detail": "AssertionError: backend=<default>: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <modu", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "no_assertions", + "message": "pytest test contains no assert statements", + "path": "eval/tests/test_backend_selection.py", + "repair_hint": "Add concrete assert statements over observable executable behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[agg]", + "reasons": [ + { + "detail": "AssertionError: backend=agg rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[pdf]", + "reasons": [ + { + "detail": "AssertionError: backend=pdf rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[ps]", + "reasons": [ + { + "detail": "AssertionError: backend=ps rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[svg]", + "reasons": [ + { + "detail": "AssertionError: backend=svg rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[template]", + "reasons": [ + { + "detail": "AssertionError: backend=template rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[agg]", + "reasons": [ + { + "detail": "AssertionError: backend=agg rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[pdf]", + "reasons": [ + { + "detail": "AssertionError: backend=pdf rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[ps]", + "reasons": [ + { + "detail": "AssertionError: backend=ps rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[svg]", + "reasons": [ + { + "detail": "AssertionError: backend=svg rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[template]", + "reasons": [ + { + "detail": "AssertionError: backend=template rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[agg]", + "reasons": [ + { + "detail": "AssertionError: backend=agg: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[pdf]", + "reasons": [ + { + "detail": "AssertionError: backend=pdf: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[ps]", + "reasons": [ + { + "detail": "AssertionError: backend=ps: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n f", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[svg]", + "reasons": [ + { + "detail": "AssertionError: backend=svg: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[template]", + "reasons": [ + { + "detail": "AssertionError: backend=template: expected exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <modul", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_and_side_effects.test_clean_run_emits_no_figure_output_files", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_and_side_effects.test_run_from_unrelated_cwd_is_clean", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_and_side_effects.test_unwritable_config_dir_file_emits_temp_warning", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_config_and_side_effects.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_and_side_effects.test_unwritable_config_dir_proc_falls_back_to_temp", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_and_side_effects.test_writable_config_dir_is_created", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_bad_rc_key_emits_exact_normalized_warning", + "reasons": [ + { + "detail": "AssertionError: bad-key rc should not abort, rc=-6 assert -6 == 0 + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_config_rc_and_stateful.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_bad_rc_key_warning_is_byte_identical_across_runs", + "reasons": [ + { + "detail": "AssertionError: assert (-6 == 0) + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate called after throwing", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_empty_string_config_dir_falls_back_to_temp", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_fresh_config_dir_accumulates_versioned_font_cache", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_missing_nested_config_dir_is_created_by_import", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_prepopulated_config_dir_is_reused_cleanly", + "reasons": [ + { + "detail": "AssertionError: assert (-6 == 0) + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate called after throwing", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_rc_file_with_comments_and_blank_lines_is_clean", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_and_stateful.test_valid_rc_file_runs_clean_and_populates_font_cache", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_on_second_rc_line_reports_line_2", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "missing_fixture_assets", + "message": "pytest test references fixture assets that are not packaged", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Package referenced fixture, resource, golden, or test data files with the eval branch.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_written_in_test", + "message": "pytest test writes to its own golden file", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Read committed golden data instead of writing expected output inside the test.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[axes.edgecolor]", + "reasons": [ + { + "detail": "AssertionError: axes.edgecolor: bad value must not abort, rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <mod", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[axes.facecolor]", + "reasons": [ + { + "detail": "AssertionError: axes.facecolor: bad value must not abort, rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <mod", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[font.size]", + "reasons": [ + { + "detail": "AssertionError: font.size: bad value must not abort, rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[font.weight]", + "reasons": [ + { + "detail": "AssertionError: font.weight: bad value must not abort, rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[lines.linestyle]", + "reasons": [ + { + "detail": "AssertionError: lines.linestyle: bad value must not abort, rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <mo", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_rc_generates_clean_stdout_and_persists_cache", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_warning_echoes_key_and_reason", + "reasons": [ + { + "detail": "AssertionError: rc=-6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImportError: can", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_bad_value_warning_is_byte_identical_across_runs", + "reasons": [ + { + "detail": "AssertionError: assert (-6 == 0) + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate called after throwing", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_rc_file_invalid_backend_does_not_abort_vs_env_path", + "reasons": [ + { + "detail": "AssertionError: rc-invalid-backend must exit 0, got -6 assert -6 == 0 + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent ca", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + }, + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_config_rc_value_errors.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_config_rc_value_errors.test_rc_file_invalid_backend_is_nonfatal_bad_value", + "reasons": [ + { + "detail": "AssertionError: rc-invalid-backend must be non-fatal, rc=-6 assert -6 == 0 + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most rece", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_plot_show_exits_zero", + "reasons": [ + { + "detail": "AssertionError: default plot+show: expected clean exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_plot_show_leaves_stderr_empty", + "reasons": [ + { + "detail": "AssertionError: unexpected rc -6 assert -6 == 0 + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate called", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_plot_show_leaves_stdout_empty", + "reasons": [ + { + "detail": "AssertionError: unexpected rc -6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_run_completes_within_budget", + "reasons": [ + { + "detail": "AssertionError: unexpected rc -6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_run_has_no_numpy_incompatibility_block", + "reasons": [ + { + "detail": "AssertionError: unexpected rc -6 stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153, in <module>\\n from . import lib\\nImpor", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_run_has_no_temporary_config_warning", + "reasons": [ + { + "detail": "AssertionError: unexpected rc -6 assert -6 == 0 + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate called", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_clean_run_without_explicit_backend_still_terminates", + "reasons": [ + { + "detail": "AssertionError: no-backend plot+show: expected clean exit 0 but got -6 (stderr='Traceback (most recent call last):\\n File \"/workspace/golden-2/eval/test_resources/numpy15/numpy/__init__.py\", line 153,", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_runtime_plot_show.test_two_consecutive_runs_are_byte_identical", + "reasons": [ + { + "detail": "AssertionError: nonzero rc -6/-6 assert (-6 == 0) + where -6 = CompletedProcess(args=['/workspace/golden-2/executable'], returncode=-6, stdout='', stderr='Traceback (most recent cal...nterminate calle", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + } + ], + "tests": [ + "eval.tests.test_backend_errors.test_cairo_backend_aborts_with_pyplot_throw", + "eval.tests.test_backend_errors.test_cairo_backend_full_stderr_golden", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[DefinitelyNotABackend]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_1]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_2]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[FakeBackend_3]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[NoSuchBackend]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[NotARealBackend]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[SomeGUIbackend]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[WebAggMissingPorts]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[my_custom_backend]", + "eval.tests.test_backend_errors.test_invalid_backend_aborts_and_echoes_lowercased_name[qt5agg_typo]", + "eval.tests.test_backend_errors.test_invalid_backend_does_not_hit_pyplot_throw", + "eval.tests.test_backend_errors.test_invalid_backend_matches_exact_stderr_golden", + "eval.tests.test_backend_errors.test_invalid_backend_stderr_is_repeatable", + "eval.tests.test_backend_errors.test_pylab_failure_aborts_before_plot_show", + "eval.tests.test_backend_errors.test_pylab_import_failure_aborts_with_pylab_throw", + "eval.tests.test_backend_errors.test_pylab_import_failure_full_stderr_golden", + "eval.tests.test_backend_selection.test_all_valid_backends_pass_unique_config_dirs", + "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[Agg]", + "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[PDF]", + "eval.tests.test_backend_selection.test_backend_name_is_case_normalized[Svg]", + "eval.tests.test_backend_selection.test_default_backend_when_unset", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[agg]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[pdf]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[ps]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[svg]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_numpy_incompatibility[template]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[agg]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[pdf]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[ps]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[svg]", + "eval.tests.test_backend_selection.test_valid_backend_emits_no_temp_config_warning[template]", + "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[agg]", + "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[pdf]", + "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[ps]", + "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[svg]", + "eval.tests.test_backend_selection.test_valid_backend_exits_cleanly[template]", + "eval.tests.test_config_and_side_effects.test_clean_run_emits_no_figure_output_files", + "eval.tests.test_config_and_side_effects.test_run_from_unrelated_cwd_is_clean", + "eval.tests.test_config_and_side_effects.test_unwritable_config_dir_file_emits_temp_warning", + "eval.tests.test_config_and_side_effects.test_unwritable_config_dir_proc_falls_back_to_temp", + "eval.tests.test_config_and_side_effects.test_writable_config_dir_is_created", + "eval.tests.test_config_rc_and_stateful.test_bad_rc_key_emits_exact_normalized_warning", + "eval.tests.test_config_rc_and_stateful.test_bad_rc_key_warning_is_byte_identical_across_runs", + "eval.tests.test_config_rc_and_stateful.test_empty_string_config_dir_falls_back_to_temp", + "eval.tests.test_config_rc_and_stateful.test_fresh_config_dir_accumulates_versioned_font_cache", + "eval.tests.test_config_rc_and_stateful.test_missing_nested_config_dir_is_created_by_import", + "eval.tests.test_config_rc_and_stateful.test_prepopulated_config_dir_is_reused_cleanly", + "eval.tests.test_config_rc_and_stateful.test_rc_file_with_comments_and_blank_lines_is_clean", + "eval.tests.test_config_rc_and_stateful.test_valid_rc_file_runs_clean_and_populates_font_cache", + "eval.tests.test_config_rc_value_errors.test_bad_value_on_second_rc_line_reports_line_2", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[axes.edgecolor]", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[axes.facecolor]", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[font.size]", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[font.weight]", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_emits_exact_normalized_warning[lines.linestyle]", + "eval.tests.test_config_rc_value_errors.test_bad_value_rc_generates_clean_stdout_and_persists_cache", + "eval.tests.test_config_rc_value_errors.test_bad_value_warning_echoes_key_and_reason", + "eval.tests.test_config_rc_value_errors.test_bad_value_warning_is_byte_identical_across_runs", + "eval.tests.test_config_rc_value_errors.test_rc_file_invalid_backend_does_not_abort_vs_env_path", + "eval.tests.test_config_rc_value_errors.test_rc_file_invalid_backend_is_nonfatal_bad_value", + "eval.tests.test_deliverable_identity.test_binary_embeds_cpython_startup_symbols", + "eval.tests.test_deliverable_identity.test_binary_embeds_matplotlibcpp_module_loader_string", + "eval.tests.test_deliverable_identity.test_binary_embeds_matplotlibcpp_pyplot_loader_string", + "eval.tests.test_deliverable_identity.test_binary_embeds_matplotlibcpp_show_diagnostic", + "eval.tests.test_deliverable_identity.test_binary_file_is_marked_executable", + "eval.tests.test_deliverable_identity.test_binary_is_a_64_bit_elf", + "eval.tests.test_deliverable_identity.test_binary_is_not_a_placeholder_shell_script", + "eval.tests.test_deliverable_identity.test_binary_links_libpython3_10", + "eval.tests.test_deliverable_identity.test_binary_markers_collected[Call to show() failed.]", + "eval.tests.test_deliverable_identity.test_binary_markers_collected[Error loading module matplotlib!]", + "eval.tests.test_deliverable_identity.test_binary_markers_collected[Error loading module matplotlib.pyplot!]", + "eval.tests.test_deliverable_identity.test_binary_resolves_from_branch_root", + "eval.tests.test_runtime_plot_show.test_clean_plot_show_exits_zero", + "eval.tests.test_runtime_plot_show.test_clean_plot_show_leaves_stderr_empty", + "eval.tests.test_runtime_plot_show.test_clean_plot_show_leaves_stdout_empty", + "eval.tests.test_runtime_plot_show.test_clean_run_completes_within_budget", + "eval.tests.test_runtime_plot_show.test_clean_run_has_no_numpy_incompatibility_block", + "eval.tests.test_runtime_plot_show.test_clean_run_has_no_temporary_config_warning", + "eval.tests.test_runtime_plot_show.test_clean_run_without_explicit_backend_still_terminates", + "eval.tests.test_runtime_plot_show.test_two_consecutive_runs_are_byte_identical" + ] + } + }, + "commit": "ef0383f1315d32e0156335e10b82e90b334f6d9f", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.7761197990529878, + "eval_clean_hashes": [ + "641ae68df1cea22fa336f85c973f8eeea6392074968d190bd4e3d9129d88de15" + ], + "input_record": { + "commit": "ef0383f1315d32e0156335e10b82e90b334f6d9f", + "difficulty": "easy", + "difficulty_code_lines": 2986, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 2986, + "difficulty_runtime_deps": 1, + "difficulty_score": 1.7761197990529878, + "difficulty_test_code_lines": 594, + "full_name": "lava/matplotlib-cpp", + "input_joern_zip": "cpp_joern/lava__matplotlib-cpp.zip", + "joern_status": true, + "joern_time": 7.946258842013776, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 821, + "similarity": 0.4645847678184509 + } + ], + "repo_path": "cpp/lava__matplotlib-cpp", + "source": "commit:ef0383f1315d32e0156335e10b82e90b334f6d9f", + "status": "done", + "url": "https://github.com/lava/matplotlib-cpp" + }, + "instance_id": "lava__matplotlib-cpp.ef0383f", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "lava/matplotlib-cpp" +} diff --git a/lava--matplotlib-cpp.ef0383f/tests/test.sh b/lava--matplotlib-cpp.ef0383f/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/lava--matplotlib-cpp.ef0383f/tests/workspace.tar.gz b/lava--matplotlib-cpp.ef0383f/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b2ad7d16ece023434782952884d587c76b66c273 --- /dev/null +++ b/lava--matplotlib-cpp.ef0383f/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:020f0066d02e64ca124eebcb947333ff53696d0a71d715a05377bcfafde597ef +size 23338 diff --git a/layeh--kjv.0b6a9ce/environment/Dockerfile b/layeh--kjv.0b6a9ce/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..8acccc9e7709c4fa205034773e0c1c02b32a9d89 --- /dev/null +++ b/layeh--kjv.0b6a9ce/environment/Dockerfile @@ -0,0 +1,56 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils libtool libncurses-dev meson ninja-build python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.10 +ARG CMAKE_PYPI_INDEX_URL=https://pypi.org/simple +RUN set -eux; python3 -m pip install --no-cache-dir --index-url "${CMAKE_PYPI_INDEX_URL}" --trusted-host "mirror.example.invalid" "cmake==${CMAKE_VERSION}"; cmake --version; ctest --version; cpack --version +# programgym_quota_aware_nproc=1 +RUN set -eux; printf '%s\n' '#!/bin/sh' 'if [ "$#" -gt 0 ]; then exec /usr/bin/nproc "$@"; fi' 'visible="$(/usr/bin/nproc)"' 'quota=""' 'period=""' 'if [ -r /sys/fs/cgroup/cpu.max ]; then' ' set -- $(cat /sys/fs/cgroup/cpu.max)' ' quota="${1:-}"' ' period="${2:-}"' 'elif [ -r /sys/fs/cgroup/cpu/cpu.cfs_quota_us ] && [ -r /sys/fs/cgroup/cpu/cpu.cfs_period_us ]; then' ' quota="$(cat /sys/fs/cgroup/cpu/cpu.cfs_quota_us)"' ' period="$(cat /sys/fs/cgroup/cpu/cpu.cfs_period_us)"' fi 'if [ -n "$quota" ] && [ "$quota" != max ] && [ "$quota" -gt 0 ] 2>/dev/null && [ "$period" -gt 0 ] 2>/dev/null; then' ' limit=$(( (quota + period - 1) / period ))' ' if [ "$limit" -lt 1 ]; then limit=1; fi' ' if [ "$limit" -lt "$visible" ]; then visible="$limit"; fi' fi 'printf "%s\n" "$visible"' > /usr/local/bin/nproc; chmod 0755 /usr/local/bin/nproc; /usr/local/bin/nproc >/dev/null +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/layeh--kjv.0b6a9ce/environment/download.sh b/layeh--kjv.0b6a9ce/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..cd140c98ea76208b54ea6e361294a5b72df2c374 --- /dev/null +++ b/layeh--kjv.0b6a9ce/environment/download.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +# +# download.sh — ProgramGym networked dependency stage for layeh/kjv +# +# Standalone and source-safe: this file is sourced via `source /source_ro/download.sh`, +# never executed as a program. It must not depend on any repository source file (the +# source tree is unavailable during this stage) and must never perform a build step. +# +# The kjv C project builds with `make` and needs the GNU readline development headers +# (readline.h / history.h) to compile src/kjv_main.c and link with -lreadline. The base +# image already provides gcc, make, awk, build-essential, and the libreadline8 runtime, +# so the only missing build dependency here is libreadline-dev. + +export DEBIAN_FRONTEND=noninteractive + +# Install the readline development headers if they are not already present. +# Idempotent: once /usr/include/readline/readline.h exists, this is a no-op. +if [ ! -f /usr/include/readline/readline.h ]; then + apt-get update + apt-get install -y libreadline-dev +fi + +# No other dependencies, caches, or environment variables are required for the make build. +# gcc/make/awk are already present in the base image. Nothing here compiles or links. diff --git a/layeh--kjv.0b6a9ce/environment/executable b/layeh--kjv.0b6a9ce/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..076c49a606cf5f1f5d13946f0fad0ef2c9bafc2f --- /dev/null +++ b/layeh--kjv.0b6a9ce/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8525dffbdfb617c83976717c0aeb8b76f18976e94e3a66068b9d7c21053aa5f5 +size 5760312 diff --git a/layeh--kjv.0b6a9ce/environment/harbor_prepare_download_env.sh b/layeh--kjv.0b6a9ce/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/layeh--kjv.0b6a9ce/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/layeh--kjv.0b6a9ce/environment/workspace.tar.gz b/layeh--kjv.0b6a9ce/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9a2151fdddbbcc2a447aabe9954998371acd493d --- /dev/null +++ b/layeh--kjv.0b6a9ce/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76406bef778d76a64ff4f939ffabee5cfee92d50db7899756c44db9ee6f0813b +size 1664761 diff --git a/layeh--kjv.0b6a9ce/instruction.md b/layeh--kjv.0b6a9ce/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/layeh--kjv.0b6a9ce/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/layeh--kjv.0b6a9ce/solution/solve.sh b/layeh--kjv.0b6a9ce/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/layeh--kjv.0b6a9ce/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/layeh--kjv.0b6a9ce/task.toml b/layeh--kjv.0b6a9ce/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5483c2081d5782febe4f201b51cdfc93f0569e6c --- /dev/null +++ b/layeh--kjv.0b6a9ce/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/layeh--kjv.0b6a9ce" +description = "Synthetic ProgramGym cleanroom reconstruction task for layeh/kjv" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "c"] + +[metadata] +source = "ProgramGym" +instance_id = "layeh__kjv.0b6a9ce" +repository = "layeh/kjv" +commit = "0b6a9ceb1b768b7ab7e29a06b59fc318ce88cbf0" +language = "c" +difficulty = "easy" +difficulty_score = 0.9309490311675228 +test_branches = 4 +test_count = 1174 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/layeh--kjv.0b6a9ce/tests/Dockerfile b/layeh--kjv.0b6a9ce/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..af44b3d1754339c76f5704a76db5a06fd46920ab --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/Dockerfile @@ -0,0 +1,70 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip python3-dev autoconf automake gettext file binutils libtool libncurses-dev meson ninja-build python3-pytest python3-pytest-xdist python3-coverage && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.10 +ARG CMAKE_PYPI_INDEX_URL=https://pypi.org/simple +RUN set -eux; python3 -m pip install --no-cache-dir --index-url "${CMAKE_PYPI_INDEX_URL}" --trusted-host "mirror.example.invalid" "cmake==${CMAKE_VERSION}"; cmake --version; ctest --version; cpack --version +# programgym_quota_aware_nproc=1 +RUN set -eux; printf '%s\n' '#!/bin/sh' 'if [ "$#" -gt 0 ]; then exec /usr/bin/nproc "$@"; fi' 'visible="$(/usr/bin/nproc)"' 'quota=""' 'period=""' 'if [ -r /sys/fs/cgroup/cpu.max ]; then' ' set -- $(cat /sys/fs/cgroup/cpu.max)' ' quota="${1:-}"' ' period="${2:-}"' 'elif [ -r /sys/fs/cgroup/cpu/cpu.cfs_quota_us ] && [ -r /sys/fs/cgroup/cpu/cpu.cfs_period_us ]; then' ' quota="$(cat /sys/fs/cgroup/cpu/cpu.cfs_quota_us)"' ' period="$(cat /sys/fs/cgroup/cpu/cpu.cfs_period_us)"' fi 'if [ -n "$quota" ] && [ "$quota" != max ] && [ "$quota" -gt 0 ] 2>/dev/null && [ "$period" -gt 0 ] 2>/dev/null; then' ' limit=$(( (quota + period - 1) / period ))' ' if [ "$limit" -lt 1 ]; then limit=1; fi' ' if [ "$limit" -lt "$visible" ]; then visible="$limit"; fi' fi 'printf "%s\n" "$visible"' > /usr/local/bin/nproc; chmod 0755 /usr/local/bin/nproc; /usr/local/bin/nproc >/dev/null +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN set -eu; \ + pip_break_system_packages=""; \ + if python3 -m pip install --help | grep -q -- '--break-system-packages'; then \ + pip_break_system_packages="--break-system-packages"; \ + fi; \ + python3 -m pip install ${pip_break_system_packages} \ + --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_01.tar.gz b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2805b6452ba9cccbb50a80d8d84218c49869e02f --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4aec20953773d670cb2151b668a1c5eb120cb5ccc8a6c3921606e4871d24770a +size 19703 diff --git a/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_02.tar.gz b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ffbd8e04ffb3513570aa2c511deb81845067414f --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b3e6a0c630787a815d85d407a2c06f84333469acccb4493c7d2203008e101c1 +size 29909 diff --git a/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_03.tar.gz b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6ce1808ce35503f81640eb2ed80f7d239d6311e0 --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3490c005646e6a80e9800b1379f5e00c6952d7c7a31bc8894ea0858e6910606 +size 24892 diff --git a/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_04.tar.gz b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..891b727d5ef3c52886113aa280a10ea80f4b0fc5 --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:097f177b03465138f8aadd374f6ef33ecdbe1901444a363406885afd027a693a +size 17814 diff --git a/layeh--kjv.0b6a9ce/tests/download.sh b/layeh--kjv.0b6a9ce/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..cd140c98ea76208b54ea6e361294a5b72df2c374 --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/download.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +# +# download.sh — ProgramGym networked dependency stage for layeh/kjv +# +# Standalone and source-safe: this file is sourced via `source /source_ro/download.sh`, +# never executed as a program. It must not depend on any repository source file (the +# source tree is unavailable during this stage) and must never perform a build step. +# +# The kjv C project builds with `make` and needs the GNU readline development headers +# (readline.h / history.h) to compile src/kjv_main.c and link with -lreadline. The base +# image already provides gcc, make, awk, build-essential, and the libreadline8 runtime, +# so the only missing build dependency here is libreadline-dev. + +export DEBIAN_FRONTEND=noninteractive + +# Install the readline development headers if they are not already present. +# Idempotent: once /usr/include/readline/readline.h exists, this is a no-op. +if [ ! -f /usr/include/readline/readline.h ]; then + apt-get update + apt-get install -y libreadline-dev +fi + +# No other dependencies, caches, or environment variables are required for the make build. +# gcc/make/awk are already present in the base image. Nothing here compiles or links. diff --git a/layeh--kjv.0b6a9ce/tests/executable b/layeh--kjv.0b6a9ce/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..076c49a606cf5f1f5d13946f0fad0ef2c9bafc2f --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8525dffbdfb617c83976717c0aeb8b76f18976e94e3a66068b9d7c21053aa5f5 +size 5760312 diff --git a/layeh--kjv.0b6a9ce/tests/harbor_prepare_download_env.sh b/layeh--kjv.0b6a9ce/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/layeh--kjv.0b6a9ce/tests/programgym_evaluator.py b/layeh--kjv.0b6a9ce/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/layeh--kjv.0b6a9ce/tests/programgym_task.json b/layeh--kjv.0b6a9ce/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..1a7b089a14db51c3d3655aec4679151d0e8a55f8 --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/programgym_task.json @@ -0,0 +1,2096 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_extra_verses.test_book_scoped_search_confines_to_book", + "eval.tests.test_extra_verses.test_chapter_range_opens_at_verse_one", + "eval.tests.test_extra_verses.test_chapter_scoped_search_confines_to_chapter", + "eval.tests.test_extra_verses.test_reference_range_and_set_exact[John 3:1-2-John 3:1 There was a man of the Pharisees, named Nicodemus, a ruler of the Jews:\\nJohn 3:2 The same came to Jesus by night, and said unto him, Rabbi, we know that thou art a teacher come from God: for no man can do these miracles that thou doest, except God be with him.\\n]", + "eval.tests.test_extra_verses.test_reference_range_and_set_exact[John 3:16,18,19-John 3:16 For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.\\nJohn 3:18 He that believeth on him is not condemned: but he that believeth not is condemned already, because he hath not believed in the name of the only begotten Son of God.\\nJohn 3:19 And this is the condemnation, that light is come into the world, and men loved darkness rather than light, because their deeds were evil.\\n]", + "eval.tests.test_extra_verses.test_reference_range_and_set_exact[John 3:16-17-John 3:16 For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.\\nJohn 3:17 For God sent not his Son into the world to condemn the world; but that the world through him might be saved.\\n]", + "eval.tests.test_extra_verses.test_short_chapter_counts_two_verses", + "eval.tests.test_extra_verses.test_single_verse_exact_text[1 John 1:9-1 John 1:9 If we confess our sins, he is faithful and just to forgive us our sins, and to cleanse us from all unrighteousness.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Genesis 1:26-Genesis 1:26 And God said, Let us make man in our image, after our likeness: and let them have dominion over the fish of the sea, and over the fowl of the air, and over the cattle, and over all the earth, and over every creeping thing that creepeth upon the earth.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Isaiah 41:10-Isaiah 41:10 Fear thou not; for I am with thee: be not dismayed; for I am thy God: I will strengthen thee; yea, I will help thee; yea, I will uphold thee with the right hand of my righteousness.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Jeremiah 29:11-Jeremiah 29:11 For I know the thoughts that I think toward you, saith the LORD, thoughts of peace, and not of evil, to give you an expected end.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[John 14:6-John 14:6 Jesus saith unto him, I am the way, the truth, and the life: no man cometh unto the Father, but by me.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[John 8:32-John 8:32 And ye shall know the truth, and the truth shall make you free.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Matthew 5:9-Matthew 5:9 Blessed are the peacemakers: for they shall be called the children of God.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Philippians 4:13-Philippians 4:13 I can do all things through Christ which strengtheneth me.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Proverbs 3:6-Proverbs 3:6 In all thy ways acknowledge him, and he shall direct thy paths.]", + "eval.tests.test_extra_verses.test_single_verse_exact_text[Romans 3:23-Romans 3:23 For all have sinned, and come short of the glory of God;]", + "eval.tests.test_extra_verses.test_singular_psalm_abbreviation_resolves", + "eval.tests.test_flag_parsing.test_A_alpha_value_stderr_exact", + "eval.tests.test_flag_parsing.test_A_consumes_positional_as_value", + "eval.tests.test_flag_parsing.test_A_missing_argument_stderr_exact", + "eval.tests.test_flag_parsing.test_A_negative_context_renders_rest_of_chapter", + "eval.tests.test_flag_parsing.test_A_partial_number_stderr_exact", + "eval.tests.test_flag_parsing.test_A_valid_context_after_renders", + "eval.tests.test_flag_parsing.test_A_whitespace_suffix_stderr_exact", + "eval.tests.test_flag_parsing.test_A_zero_is_valid_boundary", + "eval.tests.test_flag_parsing.test_B_alpha_value_stderr_exact", + "eval.tests.test_flag_parsing.test_B_missing_argument_stderr_exact", + "eval.tests.test_flag_parsing.test_B_partial_number_stderr_exact", + "eval.tests.test_flag_parsing.test_B_valid_with_positional_renders", + "eval.tests.test_flag_parsing.test_book_chapter_joins_across_args", + "eval.tests.test_flag_parsing.test_chapter_context_flag_renders_whole_chapter", + "eval.tests.test_flag_parsing.test_combined_context_flags_after_before", + "eval.tests.test_flag_parsing.test_flag_after_double_dash_is_positional", + "eval.tests.test_flag_parsing.test_flag_e_changes_citation_but_not_error_text", + "eval.tests.test_flag_parsing.test_flag_group_error_stdout_empty", + "eval.tests.test_flag_parsing.test_flag_group_with_unknown_reports_group_member", + "eval.tests.test_flag_parsing.test_flag_group_with_unknown_variant", + "eval.tests.test_flag_parsing.test_long_help_flag_stderr_exact", + "eval.tests.test_flag_parsing.test_positional_join_after_flags", + "eval.tests.test_flag_parsing.test_unknown_capital_j_stderr_exact", + "eval.tests.test_flag_parsing.test_unknown_q_stderr_exact", + "eval.tests.test_flag_parsing.test_unknown_x_stderr_exact", + "eval.tests.test_flag_parsing.test_unknown_z_stderr_exact", + "eval.tests.test_help_usage.test_group_help_hl_prints_banner", + "eval.tests.test_help_usage.test_group_help_lh_prints_banner", + "eval.tests.test_help_usage.test_help_banner_documents_all_flags", + "eval.tests.test_help_usage.test_help_banner_ends_with_search_line", + "eval.tests.test_help_usage.test_help_banner_program_flags_block", + "eval.tests.test_help_usage.test_help_banner_reference_forms_block", + "eval.tests.test_help_usage.test_help_banner_search_forms_block", + "eval.tests.test_help_usage.test_help_banner_starts_with_usage_line", + "eval.tests.test_help_usage.test_help_combined_with_list_books_wins", + "eval.tests.test_help_usage.test_help_exact_banner_first_line", + "eval.tests.test_help_usage.test_help_ignores_context_flags", + "eval.tests.test_help_usage.test_help_ignores_positional_reference", + "eval.tests.test_help_usage.test_help_stdout_matches_banner_exactly", + "eval.tests.test_help_usage.test_help_write_nothing_to_stderr", + "eval.tests.test_help_usage.test_list_books_combined_with_help_wins", + "eval.tests.test_help_usage.test_repeated_help_flags", + "eval.tests.test_interactive.test_interactive_blank_line_keeps_loop", + "eval.tests.test_interactive.test_interactive_blank_only_transcript", + "eval.tests.test_interactive.test_interactive_context_after_applies_in_session", + "eval.tests.test_interactive.test_interactive_immediate_eof", + "eval.tests.test_interactive.test_interactive_invalid_ref_prints_prompt_only", + "eval.tests.test_interactive.test_interactive_not_entered_when_positional", + "eval.tests.test_interactive.test_interactive_prompt_per_line", + "eval.tests.test_interactive.test_interactive_ref_then_blank_then_ref_exact", + "eval.tests.test_interactive.test_interactive_search_line", + "eval.tests.test_interactive.test_interactive_single_reference_exact", + "eval.tests.test_interactive.test_interactive_three_references_frames", + "eval.tests.test_interactive.test_interactive_two_inline_verses_in_one_line", + "eval.tests.test_interactive.test_interactive_two_references_exact", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[0-Genesis (Ge)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[1-Exodus (Exo)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[10-1 Kings (1Ki)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[11-2 Kings (2Ki)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[12-1 Chronicles (1Chr)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[13-2 Chronicles (2Chr)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[14-Ezra (Ezra)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[15-Nehemiah (Neh)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[16-Esther (Est)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[17-Job (Job)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[18-Psalms (Psa)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[19-Proverbs (Prv)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[2-Leviticus (Lev)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[20-Ecclesiastes (Eccl)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[21-Song of Solomon (SSol)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[22-Isaiah (Isa)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[23-Jeremiah (Jer)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[24-Lamentations (Lam)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[25-Ezekiel (Eze)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[26-Daniel (Dan)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[27-Hosea (Hos)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[28-Joel (Joel)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[29-Amos (Amos)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[3-Numbers (Num)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[30-Obadiah (Obad)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[31-Jonah (Jonah)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[32-Micah (Mic)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[33-Nahum (Nahum)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[34-Habakkuk (Hab)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[35-Zephaniah (Zep)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[36-Haggai (Hag)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[37-Zechariah (Zec)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[38-Malachi (Mal)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[39-Matthew (Mat)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[4-Deuteronomy (Deu)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[40-Mark (Mark)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[41-Luke (Luke)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[42-John (John)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[43-The Acts (Acts)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[44-Romans (Rom)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[45-1 Corinthians (1Cor)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[46-2 Corinthians (2Cor)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[47-Galatians (Gal)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[48-Ephesians (Eph)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[49-Philippians (Phi)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[5-Joshua (Josh)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[50-Colossians (Col)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[51-1 Thessalonians (1Th)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[52-2 Thessalonians (2Th)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[53-1 Timothy (1Tim)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[54-2 Timothy (2Tim)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[55-Titus (Titus)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[56-Philemon (Phmn)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[57-Hebrews (Heb)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[58-James (Jas)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[59-1 Peter (1Pet)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[6-Judges (Jdgs)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[60-2 Peter (2Pet)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[61-1 John (1Jn)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[62-2 John (2Jn)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[63-3 John (3Jn)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[64-Jude (Jude)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[65-Revelation (Rev)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[7-Ruth (Ruth)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[8-1 Samuel (1Sm)]", + "eval.tests.test_list_books.test_each_book_entry_matches_book_list_slot[9-2 Samuel (2Sm)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Chronicles (1Chr)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Corinthians (1Cor)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 John (1Jn)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Kings (1Ki)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Peter (1Pet)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Samuel (1Sm)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Thessalonians (1Th)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[1 Timothy (1Tim)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Chronicles (2Chr)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Corinthians (2Cor)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 John (2Jn)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Kings (2Ki)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Peter (2Pet)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Samuel (2Sm)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Thessalonians (2Th)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[2 Timothy (2Tim)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[3 John (3Jn)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Amos (Amos)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Colossians (Col)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Daniel (Dan)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Deuteronomy (Deu)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Ecclesiastes (Eccl)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Ephesians (Eph)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Esther (Est)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Exodus (Exo)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Ezekiel (Eze)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Ezra (Ezra)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Galatians (Gal)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Genesis (Ge)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Habakkuk (Hab)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Haggai (Hag)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Hebrews (Heb)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Hosea (Hos)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Isaiah (Isa)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[James (Jas)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Jeremiah (Jer)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Job (Job)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Joel (Joel)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[John (John)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Jonah (Jonah)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Joshua (Josh)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Jude (Jude)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Judges (Jdgs)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Lamentations (Lam)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Leviticus (Lev)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Luke (Luke)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Malachi (Mal)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Mark (Mark)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Matthew (Mat)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Micah (Mic)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Nahum (Nahum)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Nehemiah (Neh)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Numbers (Num)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Obadiah (Obad)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Philemon (Phmn)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Philippians (Phi)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Proverbs (Prv)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Psalms (Psa)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Revelation (Rev)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Romans (Rom)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Ruth (Ruth)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Song of Solomon (SSol)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[The Acts (Acts)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Titus (Titus)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Zechariah (Zec)]", + "eval.tests.test_list_books.test_each_book_entry_renders_verbatim[Zephaniah (Zep)]", + "eval.tests.test_list_books.test_list_books_after_double_dash_is_not_list", + "eval.tests.test_list_books.test_list_books_executable_output_roundtrips_book_list", + "eval.tests.test_list_books.test_list_books_first_entry_is_genesis", + "eval.tests.test_list_books.test_list_books_has_exactly_sixty_six_entries", + "eval.tests.test_list_books.test_list_books_ignores_book_chapter_reference", + "eval.tests.test_list_books.test_list_books_ignores_positional_reference", + "eval.tests.test_list_books.test_list_books_last_entry_is_revelation", + "eval.tests.test_list_books.test_list_books_matches_book_list_exactly", + "eval.tests.test_list_books.test_list_books_old_testament_opening_order", + "eval.tests.test_list_books.test_list_books_with_context_flag", + "eval.tests.test_list_books.test_list_books_with_highlight_flag", + "eval.tests.test_list_books.test_list_books_with_pretty_flag", + "eval.tests.test_list_books.test_list_books_writes_plain_lines", + "eval.tests.test_rendering.test_highlight_emits_ansi_bracketing_citation", + "eval.tests.test_rendering.test_highlight_has_reset_sequences", + "eval.tests.test_rendering.test_plain_output_has_no_ansi", + "eval.tests.test_rendering.test_pretty_pager_no_stdout_on_pipe", + "eval.tests.test_rendering.test_render_abbreviation_resolves", + "eval.tests.test_rendering.test_render_book_chapter_starts_at_verse_one", + "eval.tests.test_rendering.test_render_book_scoped_search", + "eval.tests.test_rendering.test_render_chapter_context_whole_chapter", + "eval.tests.test_rendering.test_render_chapter_last_verse_reachable", + "eval.tests.test_rendering.test_render_context_after_one", + "eval.tests.test_rendering.test_render_context_after_two", + "eval.tests.test_rendering.test_render_context_before_one", + "eval.tests.test_rendering.test_render_context_both_sides", + "eval.tests.test_rendering.test_render_empty_reference_silent", + "eval.tests.test_rendering.test_render_exact_set_verses_only", + "eval.tests.test_rendering.test_render_invalid_reference_silent", + "eval.tests.test_rendering.test_render_multi_arg_join_equals_single_arg", + "eval.tests.test_rendering.test_render_quoted_reference_exact", + "eval.tests.test_rendering.test_render_search_all_books", + "eval.tests.test_rendering.test_render_search_no_match_empty", + "eval.tests.test_rendering.test_render_single_verse_exact", + "eval.tests.test_rendering.test_render_triple_arg_join", + "eval.tests.test_rendering.test_render_verse_range_both_endpoints", + "eval.tests.test_rendering.test_render_verse_set_comma", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Exo 20:3-Exodus 20:3 Thou shalt have no other gods before me.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Gen 1:1-Genesis 1:1 In the beginning God created the heaven and the earth.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Mat 1:1-Matthew 1:1 The book of the generation of Jesus Christ, the son of David, the son of Abraham.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Mat 8:28-Matthew 8:28 And when he was come to the other side into the country of the Gergesenes, there met him two possessed with devils, coming out of the tombs, exceeding fierce, so that no man might pass by that way.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Psa 23:1-Psalms 23:1 The LORD is my shepherd; I shall not want.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Rev 22:20-Revelation 22:20 He which testifieth these things saith, Surely I come quickly. Amen. Even so, come, Lord Jesus.]", + "eval.tests.test_rendering_param.test_render_abbreviation_resolves_to_canonical[Rom 8:28-Romans 8:28 And we know that all things work together for good to them that love God, to them who are the called according to his purpose.]", + "eval.tests.test_rendering_param.test_render_multi_arg_join_exact[argv0-John 3:16 For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.]", + "eval.tests.test_rendering_param.test_render_multi_arg_join_exact[argv1-Genesis 1:1 In the beginning God created the heaven and the earth.]", + "eval.tests.test_rendering_param.test_render_multi_arg_join_exact[argv2-Psalms 23:1 The LORD is my shepherd; I shall not want.]", + "eval.tests.test_rendering_param.test_render_multi_arg_join_exact[argv3-Romans 8:28 And we know that all things work together for good to them that love God, to them who are the called according to his purpose.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Acts 1:8-The Acts 1:8 But ye shall receive power, after that the Holy Ghost is come upon you: and ye shall be witnesses unto me both in Jerusalem, and in all Judaea, and in Samaria, and unto the uttermost part of the earth.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Exodus 20:1-Exodus 20:1 And God spake all these words, saying,]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Exodus 20:3-Exodus 20:3 Thou shalt have no other gods before me.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Genesis 1:1-Genesis 1:1 In the beginning God created the heaven and the earth.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Genesis 1:2-Genesis 1:2 And the earth was without form, and void; and darkness was upon the face of the deep. And the Spirit of God moved upon the face of the waters.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[John 11:35-John 11:35 Jesus wept.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[John 1:1-John 1:1 In the beginning was the Word, and the Word was with God, and the Word was God.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[John 3:16-John 3:16 For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Proverbs 3:5-Proverbs 3:5 Trust in the LORD with all thine heart; and lean not unto thine own understanding.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Psalms 23:1-Psalms 23:1 The LORD is my shepherd; I shall not want.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Psalms 23:4-Psalms 23:4 Yea, though I walk through the valley of the shadow of death, I will fear no evil: for thou art with me; thy rod and thy staff they comfort me.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Revelation 22:20-Revelation 22:20 He which testifieth these things saith, Surely I come quickly. Amen. Even so, come, Lord Jesus.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Revelation 22:21-Revelation 22:21 The grace of our Lord Jesus Christ be with you all. Amen.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Romans 8:28-Romans 8:28 And we know that all things work together for good to them that love God, to them who are the called according to his purpose.]", + "eval.tests.test_rendering_param.test_render_single_verse_exact_line[Romans 8:29-Romans 8:29 For whom he did foreknow, he also did predestinate to be conformed to the image of his Son, that he might be the firstborn among many brethren.]", + "eval.tests.test_round4_incremental.test_W_flag_after_reference_renders", + "eval.tests.test_round4_incremental.test_W_flag_alone_enters_interactive_prompt", + "eval.tests.test_round4_incremental.test_W_flag_before_reference_renders", + "eval.tests.test_round4_incremental.test_W_flag_combined_with_highlight", + "eval.tests.test_round4_incremental.test_W_flag_combined_with_list_books", + "eval.tests.test_round4_incremental.test_W_grouped_with_highlight_flag", + "eval.tests.test_round4_incremental.test_W_grouped_with_unknown_reports_unknown", + "eval.tests.test_round4_incremental.test_W_in_interactive_session_renders", + "eval.tests.test_round4_incremental.test_W_then_unknown_flag_reports_unknown", + "eval.tests.test_round4_incremental.test_W_with_context_after_flag", + "eval.tests.test_round4_incremental.test_W_with_help_still_prints_banner", + "eval.tests.test_round4_incremental.test_abbreviation_isa_resolves_isaiah", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[1 Corinthians 13:4-1 Corinthians 13:4 Charity suffereth long, and is kind; charity envieth not; charity vaunteth not itself, is not puffed up,]", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[Isaiah 40:31-Isaiah 40:31 But they that wait upon the LORD shall renew their strength; they shall mount up with wings as eagles; they shall run, and not be weary; and they shall walk, and not faint.]", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[Joshua 1:9-Joshua 1:9 Have not I commanded thee? Be strong and of a good courage; be not afraid, neither be thou dismayed: for the LORD thy God is with thee whithersoever thou goest.]", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[Matthew 11:28-Matthew 11:28 Come unto me, all ye that labour and are heavy laden, and I will give you rest.]", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[Proverbs 30:1-Proverbs 30:1 The words of Agur the son of Jakeh, even the prophecy: the man spake unto Ithiel, even unto Ithiel and Ucal,]", + "eval.tests.test_round4_incremental.test_additional_single_verse_exact[Psalm 91:1-Psalms 91:1 He that dwelleth in the secret place of the most High shall abide under the shadow of the Almighty.]", + "eval.tests.test_round4_incremental.test_after_before_context_clamps_before_side", + "eval.tests.test_round4_incremental.test_after_context_on_old_testament_verse", + "eval.tests.test_round4_incremental.test_before_context_clamps_at_chapter_start", + "eval.tests.test_round4_incremental.test_before_context_on_mid_chapter_verse", + "eval.tests.test_round4_incremental.test_chapter_context_on_single_verse_whole_chapter", + "eval.tests.test_round4_incremental.test_context_after_on_search_first_hit_exact", + "eval.tests.test_round4_incremental.test_context_before_on_search_first_hit_exact", + "eval.tests.test_round4_incremental.test_interactive_after_context_on_search", + "eval.tests.test_round4_incremental.test_interactive_before_context_in_session", + "eval.tests.test_round4_incremental.test_interactive_chapter_context_in_session", + "eval.tests.test_round4_incremental.test_interactive_search_transcript", + "eval.tests.test_round4_incremental.test_interactive_whitespace_spaces_are_joined", + "eval.tests.test_round4_incremental.test_tail_context_after_exact", + "eval.tests.test_round4_incremental.test_unknown_grouped_before_W_reports_unknown", + "eval.tests.test_round4_incremental.test_verse_range_exodus_20_3_4_exact", + "eval.tests.test_round4_incremental.test_verse_set_multi_book_context", + "eval.tests.test_round5_incremental.test_A_attached_value_context_after", + "eval.tests.test_round5_incremental.test_A_attached_zero_renders_single_verse", + "eval.tests.test_round5_incremental.test_A_large_context_clamps_to_chapter_end", + "eval.tests.test_round5_incremental.test_A_negative_context_same_as_large", + "eval.tests.test_round5_incremental.test_A_overflowing_context_same_as_large", + "eval.tests.test_round5_incremental.test_B_attached_value_context_before", + "eval.tests.test_round5_incremental.test_B_attached_zero_renders_single_verse", + "eval.tests.test_round5_incremental.test_B_negative_context_renders_matched_verse_only", + "eval.tests.test_round5_incremental.test_attached_value_with_trailing_letter_reports_value_error", + "eval.tests.test_round5_incremental.test_context_chapter_with_list_prints_list", + "eval.tests.test_round5_incremental.test_double_dash_then_eof_enters_prompt", + "eval.tests.test_round5_incremental.test_grouped_W_list", + "eval.tests.test_round5_incremental.test_grouped_highlight_W_list_plain", + "eval.tests.test_round5_incremental.test_grouped_hl_prints_help", + "eval.tests.test_round5_incremental.test_grouped_letter_as_A_value_reports_value_error", + "eval.tests.test_round5_incremental.test_grouped_letter_as_B_value_reports_value_error", + "eval.tests.test_round5_incremental.test_grouped_lh_prints_help", + "eval.tests.test_round5_incremental.test_grouped_list_unknown_t_reports_exact_char", + "eval.tests.test_round5_incremental.test_help_after_list_still_prints_help", + "eval.tests.test_round5_incremental.test_help_before_list_prints_help", + "eval.tests.test_round5_incremental.test_highlight_flag_does_not_colorize_list", + "eval.tests.test_round5_incremental.test_list_then_grouped_W_plain", + "eval.tests.test_round5_incremental.test_pretty_with_list_prints_list", + "eval.tests.test_round5_incremental.test_repeated_A_later_value_wins", + "eval.tests.test_round5_incremental.test_repeated_A_resets_to_zero", + "eval.tests.test_round5_incremental.test_repeated_B_resets_to_zero", + "eval.tests.test_round5_incremental.test_standalone_minus_one_reports_exact_char" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_chapter_zero_sentinel.test_chapter_zero_verse_one_selects_each_chapter_verse_one", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_chapter_zero_sentinel.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "generic_keyword_oracle", + "message": "pytest test uses a generic keyword oracle", + "path": "eval/tests/test_chapter_zero_sentinel.py", + "repair_hint": "Replace generic keyword checks with exact diagnostics, structured output, or golden comparisons.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_book_resolution.test_abbr_with_spaces_ignored", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[1Sm-1 Samuel 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[2Sm-2 Samuel 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Exo-Exodus 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Ge-Genesis 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Jas-James 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Jdgs-Judges 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Psa-Psalms 1:1]", + "eval.tests.test_book_resolution.test_abbreviation_resolves_book[Rev-Revelation 1:1]", + "eval.tests.test_book_resolution.test_ambiguous_prefix_picks_first", + "eval.tests.test_book_resolution.test_bare_digit_two_resolves_second_samuel_whole_book", + "eval.tests.test_book_resolution.test_book_self_escaping_name_match", + "eval.tests.test_book_resolution.test_case_insensitive_book_name[1 Samuel-1 Samuel 1:1]", + "eval.tests.test_book_resolution.test_case_insensitive_book_name[Genesis-Genesis 1:1]", + "eval.tests.test_book_resolution.test_case_insensitive_book_name[Psalms-Psalms 1:1]", + "eval.tests.test_book_resolution.test_case_insensitive_book_name[Revelation-Revelation 1:1]", + "eval.tests.test_book_resolution.test_case_variants_of_abbreviation", + "eval.tests.test_book_resolution.test_digit_three_with_chapter_is_unresolved", + "eval.tests.test_book_resolution.test_digit_with_space_then_chapter_is_unresolved", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Chr-1 Chronicles 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Cor-1 Corinthians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Jn-1 John 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Ki-1 Kings 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Pet-1 Peter 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Sm-1 Samuel 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Th-1 Thessalonians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[1Tim-1 Timothy 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Chr-2 Chronicles 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Cor-2 Corinthians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Jn-2 John 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Ki-2 Kings 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Pet-2 Peter 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Sm-2 Samuel 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Th-2 Thessalonians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[2Tim-2 Timothy 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[3Jn-3 John 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Amo-Amos 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Col-Colossians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Dan-Daniel 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Deu-Deuteronomy 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Eccl-Ecclesiastes 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Eph-Ephesians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Est-Esther 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Eze-Ezekiel 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Ezr-Ezra 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Gal-Galatians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Gen-Genesis 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Hab-Habakkuk 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Hag-Haggai 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Heb-Hebrews 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Hos-Hosea 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Isa-Isaiah 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Jer-Jeremiah 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Joel-Joel 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Josh-Joshua 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Lam-Lamentations 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Mal-Malachi 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Mar-Mark 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Mat-Matthew 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Neh-Nehemiah 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Num-Numbers 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Phi-Philippians 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Phmn-Philemon 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Prv-Proverbs 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Rev-Revelation 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Rom-Romans 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[SSol-Song of Solomon 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Tit-Titus 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Zec-Zechariah 1:1]", + "eval.tests.test_book_resolution.test_expanded_abbreviation_resolves[Zep-Zephaniah 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[1 Samuel-1 Samuel 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[2 Samuel-2 Samuel 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Exodus-Exodus 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Genesis-Genesis 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[John-John 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Jude-Jude 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Psalms-Psalms 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Revelation-Revelation 1:1]", + "eval.tests.test_book_resolution.test_full_book_name_first_verse[Song of Solomon-Song of Solomon 1:1]", + "eval.tests.test_book_resolution.test_prefix_ex_short_match", + "eval.tests.test_book_resolution.test_prefix_partial_gen", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[1Ch-1 Chronicles 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[1K-1 Kings 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[2Ch-2 Chronicles 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[2K-2 Kings 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Ex-Exodus 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[G-Genesis 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Gen-Genesis 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Jas-James 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Jo-Joshua 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Joh-John 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Pro-Proverbs 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[R-Ruth 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[Song-Song of Solomon 1:1]", + "eval.tests.test_book_resolution.test_prefix_short_match_resolution[TheActs-The Acts 1:1]", + "eval.tests.test_book_resolution.test_prefix_single_digit_resolves_first_samuel", + "eval.tests.test_book_resolution.test_unknown_book_exits_zero", + "eval.tests.test_book_resolution.test_unknown_book_produces_no_output", + "eval.tests.test_book_resolution.test_whitespace_insensitive_book_match", + "eval.tests.test_chapter_zero_sentinel.test_chapter_zero_psalms_whole_book_count", + "eval.tests.test_chapter_zero_sentinel.test_chapter_zero_selects_whole_book", + "eval.tests.test_chapter_zero_sentinel.test_chapter_zero_verse_one_ordered_by_chapter", + "eval.tests.test_chapter_zero_sentinel.test_chapter_zero_verse_one_selects_each_chapter_verse_one", + "eval.tests.test_chapter_zero_sentinel.test_verse_zero_selects_whole_chapter", + "eval.tests.test_cli.test_context_after_one_exact_golden", + "eval.tests.test_cli.test_context_after_two_count", + "eval.tests.test_cli.test_context_after_zero_keeps_exact_match", + "eval.tests.test_cli.test_context_before_does_not_past_chapter", + "eval.tests.test_cli.test_context_before_one_exact_refs", + "eval.tests.test_cli.test_context_chapter_first_verse_count", + "eval.tests.test_cli.test_context_chapter_flag_exact_golden", + "eval.tests.test_cli.test_help_exact_output_matches_golden", + "eval.tests.test_cli.test_help_is_on_stdout_not_stderr", + "eval.tests.test_cli.test_highlight_genesis_exact_golden", + "eval.tests.test_cli.test_highlight_keeps_plain_verse_text", + "eval.tests.test_cli.test_highlight_song_of_solomon_exact_golden", + "eval.tests.test_cli.test_invalid_A_value_exact_diagnostic[1.5]", + "eval.tests.test_cli.test_invalid_A_value_exact_diagnostic[1a]", + "eval.tests.test_cli.test_invalid_A_value_exact_diagnostic[a1]", + "eval.tests.test_cli.test_invalid_A_value_exact_diagnostic[xx]", + "eval.tests.test_cli.test_invalid_B_value_exact_diagnostic[1a]", + "eval.tests.test_cli.test_invalid_B_value_exact_diagnostic[a1]", + "eval.tests.test_cli.test_invalid_B_value_exact_diagnostic[xx]", + "eval.tests.test_cli.test_invalid_flag_exact_diagnostic[-J-kjv: invalid flag -J]", + "eval.tests.test_cli.test_invalid_flag_exact_diagnostic[-Q-kjv: invalid flag -Q]", + "eval.tests.test_cli.test_invalid_flag_exact_diagnostic[-V-kjv: invalid flag -V]", + "eval.tests.test_cli.test_invalid_flag_exact_diagnostic[-Z-kjv: invalid flag -Z]", + "eval.tests.test_cli.test_invalid_flag_exits_nonzero_regardless_of_ref", + "eval.tests.test_cli.test_invalid_flag_names_the_flag[-Q]", + "eval.tests.test_cli.test_invalid_flag_names_the_flag[-Z]", + "eval.tests.test_cli.test_list_books_exact_line_acts", + "eval.tests.test_cli.test_list_books_exact_line_first_samuel", + "eval.tests.test_cli.test_list_books_exact_line_psalms", + "eval.tests.test_cli.test_list_books_exact_output_matches_golden", + "eval.tests.test_cli.test_list_books_first_line", + "eval.tests.test_cli.test_list_books_ignores_reference_args", + "eval.tests.test_cli.test_list_books_last_line", + "eval.tests.test_cli.test_list_books_total_count", + "eval.tests.test_cli.test_no_highlight_by_default_on_pipe", + "eval.tests.test_cli_context_edges.test_context_after_at_book_end_only_verse", + "eval.tests.test_cli_context_edges.test_context_after_clamps_at_chapter_end", + "eval.tests.test_cli_context_edges.test_context_before_at_book_start_only_verse", + "eval.tests.test_cli_context_edges.test_context_before_clamps_at_chapter_start", + "eval.tests.test_cli_context_edges.test_context_chapter_active_on_set_match", + "eval.tests.test_cli_context_edges.test_context_chapter_expands_to_whole_chapter", + "eval.tests.test_cli_context_edges.test_context_chapter_with_abbrev_book", + "eval.tests.test_cli_context_edges.test_context_combined_after_and_before_count", + "eval.tests.test_cli_highlight_edges.test_highlight_composes_with_after_context", + "eval.tests.test_cli_highlight_edges.test_highlight_composes_with_before_context", + "eval.tests.test_cli_highlight_edges.test_highlight_composes_with_chapter_context", + "eval.tests.test_cli_highlight_edges.test_highlight_every_verse_in_set_is_wrapped", + "eval.tests.test_cli_highlight_edges.test_highlight_multi_word_book_name_one_underline_block", + "eval.tests.test_cli_highlight_edges.test_highlight_numeral_prefixed_book", + "eval.tests.test_cli_highlight_edges.test_highlight_single_word_book_exact_line[Genesis 1:1]", + "eval.tests.test_cli_highlight_edges.test_highlight_single_word_book_exact_line[John 3:16]", + "eval.tests.test_cli_highlight_edges.test_highlight_single_word_book_exact_line[Psalms 119:176]", + "eval.tests.test_cli_highlight_edges.test_no_highlight_when_flag_absent_even_with_context", + "eval.tests.test_context_with_search.test_context_after_book_search", + "eval.tests.test_context_with_search.test_context_after_corpus_search", + "eval.tests.test_context_with_search.test_context_before_corpus_search", + "eval.tests.test_context_with_search.test_context_both_corpus_search", + "eval.tests.test_context_with_search.test_context_chapter_of_chapter_search", + "eval.tests.test_context_with_search.test_context_chapter_of_phrase_search", + "eval.tests.test_context_with_search.test_context_chapter_of_psalms_faith", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[0]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[10]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[4]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[5]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[6]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[7]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[8]", + "eval.tests.test_digit_prefix_books.test_bare_digit_naming_no_book_is_empty[9]", + "eval.tests.test_digit_prefix_books.test_bare_digit_resolves_earliest_digit_book[1-1 Samuel 1:1]", + "eval.tests.test_digit_prefix_books.test_bare_digit_resolves_earliest_digit_book[2-2 Samuel 1:1]", + "eval.tests.test_digit_prefix_books.test_bare_digit_resolves_earliest_digit_book[3-3 John 1:1]", + "eval.tests.test_digit_prefix_books.test_bare_digit_whole_book_count[1-810]", + "eval.tests.test_digit_prefix_books.test_bare_digit_whole_book_count[2-695]", + "eval.tests.test_digit_prefix_books.test_bare_digit_whole_book_count[3-14]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbrev_missing_chapter_is_empty", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Chr-1-54-1 Chronicles 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Cor-1-31-1 Corinthians 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Jn-1-10-1 John 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Ki-1-53-1 Kings 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Pet-1-25-1 Peter 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Sm-1-28-1 Samuel 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Th-1-10-1 Thessalonians 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[1Tim-1-20-1 Timothy 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Chr-1-17-2 Chronicles 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Cor-1-24-2 Corinthians 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Jn-1-13-2 John 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Ki-2-25-2 Kings 2:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Pet-1-21-2 Peter 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Sm-1-27-2 Samuel 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Th-1-12-2 Thessalonians 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[2Tim-1-18-2 Timothy 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_abbreviation_chapter_count[3Jn-1-14-3 John 1:1]", + "eval.tests.test_digit_prefix_books.test_digit_book_full_name_matches_first_verse", + "eval.tests.test_error.test_combined_arg_reference", + "eval.tests.test_error.test_malformed_refs_produce_no_output[1:]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[:1]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[:]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[Genesis 1:1:]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[Genesis 1:]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[Genesis:1:2:3]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[Genesis:]", + "eval.tests.test_error.test_malformed_refs_produce_no_output[]", + "eval.tests.test_error.test_multi_word_book_with_spaces", + "eval.tests.test_error.test_ref_split_across_multiple_argv_elements", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[//]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis 1:1,,]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis 1:1,]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis 1:1-2 garbage]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis 1:1-2:3:4]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis 1:1-]", + "eval.tests.test_error.test_trailing_or_extra_separators_no_output[Genesis:1:1/God]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[12345]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[Genesis 999:1]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[Genesis 999]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[NotABook 1:1]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[NotABook:1]", + "eval.tests.test_error.test_unknown_book_or_out_of_range_chapter_no_output[NotABook]", + "eval.tests.test_error.test_whitespace_padded_reference", + "eval.tests.test_intset_growth.test_verse_set_growth_across_40_verses_ordering", + "eval.tests.test_intset_growth.test_verse_set_growth_exact_golden", + "eval.tests.test_intset_growth.test_verse_set_growth_first_last_refs", + "eval.tests.test_intset_growth.test_verse_set_growth_in_other_chapters[Exodus-20-26]", + "eval.tests.test_intset_growth.test_verse_set_growth_in_other_chapters[Genesis-1-31]", + "eval.tests.test_intset_growth.test_verse_set_growth_in_other_chapters[John-3-36]", + "eval.tests.test_intset_growth.test_verse_set_growth_in_other_chapters[Matthew-5-48]", + "eval.tests.test_intset_growth.test_verse_set_growth_retains_all_verses[11]", + "eval.tests.test_intset_growth.test_verse_set_growth_retains_all_verses[12]", + "eval.tests.test_intset_growth.test_verse_set_growth_retains_all_verses[15]", + "eval.tests.test_intset_growth.test_verse_set_growth_retains_all_verses[20]", + "eval.tests.test_intset_growth.test_verse_set_growth_retains_all_verses[25]", + "eval.tests.test_intset_growth.test_verse_set_growth_reversed_input_sorted", + "eval.tests.test_intset_growth.test_verse_set_growth_with_dupes_deduped", + "eval.tests.test_parser_eof_branch_empty.test_stray_number_after_set_or_range_is_empty[Genesis 1:1,2 3]", + "eval.tests.test_parser_eof_branch_empty.test_stray_number_after_set_or_range_is_empty[Genesis 1:1-2 3:4]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1-2 3 4]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1-2 3]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1-2/God]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1:1,2-3]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1:1,3-5]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1:1-2 3]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1:1-2:3 4]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis 1:1-2:3x]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis:1-2 3]", + "eval.tests.test_parser_eof_branch_empty.test_trailing_numeric_token_after_endpoint_is_empty[Genesis:1:1,3-4]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[0]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[10]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[4]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[5]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[6]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[7]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[8]", + "eval.tests.test_ref_edges.test_bare_digit_with_no_digit_book_misses[9]", + "eval.tests.test_ref_edges.test_chapter_range_colon_form_equals_space_form", + "eval.tests.test_ref_edges.test_cross_chapter_ext_exodus_exact_count_and_endpoints", + "eval.tests.test_ref_edges.test_dash_space_before_chapter_endpoint_is_whitespace_tolerant", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[! 1:1]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses['John']", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[(Genesis)]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[* 1:1]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[,1:1]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[.]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[; Genesis 1:1]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[?]", + "eval.tests.test_ref_edges.test_leading_nonbook_symbol_misses[\\\\]", + "eval.tests.test_ref_edges.test_lowercase_abbreviation_still_resolves", + "eval.tests.test_ref_edges.test_out_of_range_verses_dropped[Genesis 1:25-50-expected_refs2]", + "eval.tests.test_ref_edges.test_out_of_range_verses_dropped[Genesis 50:1,25,26-expected_refs0]", + "eval.tests.test_ref_edges.test_out_of_range_verses_dropped[Genesis 50:1,30-expected_refs1]", + "eval.tests.test_ref_edges.test_out_of_range_verses_dropped[Genesis 50:1-expected_refs3]", + "eval.tests.test_ref_edges.test_reference_starting_with_dash_is_flag_rejection", + "eval.tests.test_ref_edges.test_space_separated_set_items_equivalent_to_compact", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis 1-2 3]", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis 1-2-3]", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis 1-2x]", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis 1:1,,]", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis 1:1,2a]", + "eval.tests.test_ref_edges.test_trailing_junk_after_range_or_set_misses[Genesis:1-2x]", + "eval.tests.test_ref_edges.test_verse_set_colon_book_form_equals_space_form", + "eval.tests.test_ref_exact.test_exact_book_count[Genesis-1533]", + "eval.tests.test_ref_exact.test_exact_book_count[John-879]", + "eval.tests.test_ref_exact.test_exact_book_count[Jude-25]", + "eval.tests.test_ref_exact.test_exact_book_count[Psalms-2461]", + "eval.tests.test_ref_exact.test_exact_book_count[Revelation-404]", + "eval.tests.test_ref_exact.test_exact_chapter_colon_alternate_syntax", + "eval.tests.test_ref_exact.test_exact_chapter_count[1 John 4-21]", + "eval.tests.test_ref_exact.test_exact_chapter_count[Exodus 20-26]", + "eval.tests.test_ref_exact.test_exact_chapter_count[Genesis 1-31]", + "eval.tests.test_ref_exact.test_exact_chapter_count[John 3-36]", + "eval.tests.test_ref_exact.test_exact_chapter_count[Matthew 5-48]", + "eval.tests.test_ref_exact.test_exact_chapter_count[Psalms 119-176]", + "eval.tests.test_ref_exact.test_exact_chapter_count[Psalms 23-6]", + "eval.tests.test_ref_exact.test_exact_genesis_creation_verse", + "eval.tests.test_ref_exact.test_exact_verse_content", + "eval.tests.test_ref_exact.test_exact_verse_prints_single_line", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Chronicles 1-54]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Corinthians 1-31]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 John 1-10]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Kings 1-53]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Peter 1-25]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Thessalonians 1-10]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[1 Timothy 1-20]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[2 John 1-13]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[2 Kings 1-18]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[2 Peter 1-21]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[2 Timothy 1-18]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[3 John 1-14]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Acts 1-26]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Amos 1-15]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Colossians 1-29]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Daniel 1-21]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Deuteronomy 1-46]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Ephesians 1-23]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Exodus 1-22]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Galatians 1-24]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Genesis 2-25]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Genesis 50-26]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Habakkuk 1-17]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Hebrews 1-14]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Hosea 1-11]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Isaiah 1-31]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[James 1-27]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Job 1-22]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Joel 1-20]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Joshua 1-18]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Jude 1-25]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Judges 1-36]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Lamentations 1-22]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Leviticus 1-17]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Luke 1-80]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Mark 1-45]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Matthew 1-25]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Micah 1-16]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Nehemiah 1-11]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Numbers 1-54]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Philemon 1-25]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Philippians 1-30]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Proverbs 1-33]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Romans 1-32]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Ruth 1-22]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Titus 1-16]", + "eval.tests.test_ref_exact.test_expanded_exact_chapter_count[Zephaniah 1-18]", + "eval.tests.test_ref_exact.test_verse_set_can_repeat_adjacent", + "eval.tests.test_ref_exact.test_verse_set_dedupes_repeats", + "eval.tests.test_ref_exact.test_verse_set_high_out_of_order_sorted", + "eval.tests.test_ref_exact.test_verse_set_large_chapter_content_oracle", + "eval.tests.test_ref_exact.test_verse_set_large_chapter_selection_exact", + "eval.tests.test_ref_exact.test_verse_set_prints_ascending_when_strictly_descending", + "eval.tests.test_ref_exact.test_verse_set_prints_in_ascending_order_when_given_reversed", + "eval.tests.test_ref_exact.test_verse_set_single_value", + "eval.tests.test_ref_exact.test_verse_set_three_distinct", + "eval.tests.test_ref_exact.test_verse_set_trailing_comma_is_invalid", + "eval.tests.test_ref_range.test_chapter_range_across_books[Exodus 1-2-47]", + "eval.tests.test_ref_range.test_chapter_range_across_books[Genesis 1-1-31]", + "eval.tests.test_ref_range.test_chapter_range_across_books[Genesis 1-3-80]", + "eval.tests.test_ref_range.test_chapter_range_across_books[Genesis 49-50-59]", + "eval.tests.test_ref_range.test_chapter_range_across_books[John 1-2-76]", + "eval.tests.test_ref_range.test_chapter_range_across_books[Psalms 1-3-26]", + "eval.tests.test_ref_range.test_chapter_range_count", + "eval.tests.test_ref_range.test_chapter_range_ends_at_last_chapter_tail", + "eval.tests.test_ref_range.test_chapter_range_first_is_chapter_one", + "eval.tests.test_ref_range.test_chapter_range_single_chapter", + "eval.tests.test_ref_range.test_cross_chapter_ext_between_chapters[Exodus 20:1-20:6-6-20:1-20:6]", + "eval.tests.test_ref_range.test_cross_chapter_ext_between_chapters[Genesis 1:30-2:2-4-1:30-2:2]", + "eval.tests.test_ref_range.test_cross_chapter_ext_between_chapters[John 3:16-4:2-23-3:16-4:2]", + "eval.tests.test_ref_range.test_cross_chapter_ext_between_chapters[Psalms 119:174-119:176-3-119:174-119:176]", + "eval.tests.test_ref_range.test_cross_chapter_full_end_of_genesis_to_start_of_next", + "eval.tests.test_ref_range.test_cross_chapter_range_ext_count", + "eval.tests.test_ref_range.test_cross_chapter_range_ext_ends_at_end_verse", + "eval.tests.test_ref_range.test_cross_chapter_range_ext_middle_chapter_full_exact", + "eval.tests.test_ref_range.test_cross_chapter_range_ext_starts_at_start_verse", + "eval.tests.test_ref_range.test_max_chapter_range_psalms_1_2", + "eval.tests.test_ref_range.test_range_ext_verse_inclusive", + "eval.tests.test_ref_range.test_range_garbage_after_endpoint", + "eval.tests.test_ref_range.test_range_missing_second_endpoint", + "eval.tests.test_ref_range.test_range_reversed_endpoints_yields_nothing", + "eval.tests.test_ref_range.test_same_chapter_range_ext_equals_verse_range", + "eval.tests.test_ref_range.test_single_chapter_range_matches_bare_chapter", + "eval.tests.test_ref_range.test_verse_range_count[Exodus 20:1-20:7-7]", + "eval.tests.test_ref_range.test_verse_range_count[Genesis 1:1-2-2]", + "eval.tests.test_ref_range.test_verse_range_count[Genesis 1:1-7-7]", + "eval.tests.test_ref_range.test_verse_range_count[Genesis 1:30-31-2]", + "eval.tests.test_ref_range.test_verse_range_count[Genesis 1:31-31-1]", + "eval.tests.test_ref_range.test_verse_range_count[Psalms 119:1-3-3]", + "eval.tests.test_ref_range.test_verse_range_full_chapter_equals_chapter_exact", + "eval.tests.test_ref_range.test_verse_range_inclusive_endpoints", + "eval.tests.test_ref_search.test_book_search_abbreviation_form", + "eval.tests.test_ref_search.test_book_search_in_revelation_count", + "eval.tests.test_ref_search.test_book_search_no_match", + "eval.tests.test_ref_search.test_book_search_no_space_form", + "eval.tests.test_ref_search.test_book_search_reduced_by_book_scope", + "eval.tests.test_ref_search.test_chapter_search_colon_form", + "eval.tests.test_ref_search.test_chapter_search_count_in_chapter_two", + "eval.tests.test_ref_search.test_chapter_search_in_psalms_119", + "eval.tests.test_ref_search.test_chapter_search_john_three_god", + "eval.tests.test_ref_search.test_chapter_search_no_match", + "eval.tests.test_ref_search.test_chapter_search_space_form", + "eval.tests.test_ref_search.test_search_alternation_exact_count", + "eval.tests.test_ref_search.test_search_anchored_end_scope", + "eval.tests.test_ref_search.test_search_braced_interval_quantifier", + "eval.tests.test_ref_search.test_search_character_class_exact_count", + "eval.tests.test_ref_search.test_search_digit_class_matches_nothing", + "eval.tests.test_ref_search.test_search_dot_is_any_character_metachar", + "eval.tests.test_ref_search.test_search_empty_pattern_matches_all_verses", + "eval.tests.test_ref_search.test_search_first_line_reference", + "eval.tests.test_ref_search.test_search_impossible_literal_matches_nothing", + "eval.tests.test_ref_search.test_search_invalid_regex_returns_nothing", + "eval.tests.test_ref_search.test_search_is_case_insensitive", + "eval.tests.test_ref_search.test_search_lone_star_is_invalid_regex_empty", + "eval.tests.test_ref_search.test_search_lone_unbalanced_paren_returns_nothing", + "eval.tests.test_ref_search.test_search_no_match_returns_nothing", + "eval.tests.test_ref_search.test_search_pattern_with_spaces_stays_single_arg", + "eval.tests.test_ref_search.test_search_score_book_scoped_abbrev", + "eval.tests.test_ref_search.test_search_supports_alternation_regex", + "eval.tests.test_ref_search.test_search_supports_start_anchored_regex", + "eval.tests.test_ref_search.test_simple_word_search_matches_multiple_books", + "eval.tests.test_ref_search.test_verse_plus_search_unsupported_yields_nothing", + "eval.tests.test_search_more_word_counts.test_book_scoped_count_is_less_than_corpus_wide", + "eval.tests.test_search_more_word_counts.test_book_scoped_word_count[Genesis/faith-0]", + "eval.tests.test_search_more_word_counts.test_book_scoped_word_count[John/love-39]", + "eval.tests.test_search_more_word_counts.test_book_scoped_word_count[Proverbs/wisdom-53]", + "eval.tests.test_search_more_word_counts.test_book_scoped_word_count[Psalms/faith-21]", + "eval.tests.test_search_more_word_counts.test_space_pattern_kept_single_arg", + "eval.tests.test_search_more_word_counts.test_space_pattern_last_hit_pinned", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/earth-949]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/faith-338]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/fire-515]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/heart-895]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/heaven-691]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/light-414]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/love-546]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/peace-420]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/spirit-523]", + "eval.tests.test_search_more_word_counts.test_whole_corpus_word_count[/water-636]", + "eval.tests.test_search_scoped_counts.test_book_scoped_empty_pattern_is_whole_book", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_abbreviation_book", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[1 Samuel/God-93]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[Amos/seed-1]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[Genesis/God-206]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[John/God-70]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[Proverbs/wise-66]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[Psalms/God-392]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_exact_count[Revelation/seven-36]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_less_than_corpus_wide", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_no_term_is_scoped_positive", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_restricts_to_book[1 Samuel/God-1 Samuel ]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_restricts_to_book[Genesis/God-Genesis ]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_restricts_to_book[Proverbs/wise-Proverbs ]", + "eval.tests.test_search_scoped_counts.test_book_scoped_search_restricts_to_book[Revelation/seven-Revelation ]", + "eval.tests.test_search_scoped_counts.test_chapter_scoped_search_exact_count[Genesis:1/God-26]", + "eval.tests.test_search_scoped_counts.test_chapter_scoped_search_exact_count[Isaiah:1/God-1]", + "eval.tests.test_search_scoped_counts.test_chapter_scoped_search_exact_count[John:3/God-10]", + "eval.tests.test_search_scoped_counts.test_chapter_scoped_search_less_than_book_scoped", + "eval.tests.test_search_scoped_counts.test_chapter_scoped_search_restricts_to_chapter", + "eval.tests.test_sentinel_set_combinations.test_book_scoped_empty_search_other_book", + "eval.tests.test_sentinel_set_combinations.test_chapter_scoped_empty_search_is_whole_chapter", + "eval.tests.test_sentinel_set_combinations.test_chapter_scoped_search_no_match_is_empty", + "eval.tests.test_sentinel_set_combinations.test_chapter_zero_range_is_empty", + "eval.tests.test_sentinel_set_combinations.test_chapter_zero_verse_zero_is_whole_book", + "eval.tests.test_sentinel_set_combinations.test_descending_range_ending_at_zero_clamps_to_chapter_end", + "eval.tests.test_sentinel_set_combinations.test_verse_zero_alone_set_like_exact_sentinel", + "eval.tests.test_sentinel_set_combinations.test_verse_zero_in_set_is_dropped", + "eval.tests.test_sentinel_set_combinations.test_verse_zero_long_chapter_sentinel", + "eval.tests.test_single_chapter_books.test_philemon_verse_range_full_chapter", + "eval.tests.test_single_chapter_books.test_single_chapter_book_colon_chapter_form", + "eval.tests.test_single_chapter_books.test_single_chapter_book_exact_verse[2 John-2 John 1:13-expected0]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_exact_verse[3 John-3 John 1:14-expected1]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_exact_verse[Jude-Jude 1:24-expected3]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_exact_verse[Philemon-Philemon 1:25-expected2]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_out_of_range_verse_empty", + "eval.tests.test_single_chapter_books.test_single_chapter_book_whole_and_explicit[2 John-13-2 John 1:1 The elder unto the elect lady]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_whole_and_explicit[3 John-14-3 John 1:1 The elder unto the wellbeloved Gaius]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_whole_and_explicit[Jude-25-Jude 1:1 Jude, the servant of Jesus Christ]", + "eval.tests.test_single_chapter_books.test_single_chapter_book_whole_and_explicit[Philemon-25-Philemon 1:1 Paul, a prisoner of Jesus Christ]", + "eval.tests.test_whitespace_tolerance.test_colon_chapter_space_equals_compact[Gen : 1-Genesis 1]", + "eval.tests.test_whitespace_tolerance.test_colon_chapter_space_equals_compact[Genesis : 1-Genesis 1]", + "eval.tests.test_whitespace_tolerance.test_colon_chapter_space_equals_compact[Genesis : 1-Genesis 1]", + "eval.tests.test_whitespace_tolerance.test_multi_space_in_chapter_verse", + "eval.tests.test_whitespace_tolerance.test_space_around_chapter_range_dash_equals_compact", + "eval.tests.test_whitespace_tolerance.test_space_around_set_commas_equals_compact[Genesis 1: 1 , 3 , 5]", + "eval.tests.test_whitespace_tolerance.test_space_around_set_commas_equals_compact[Genesis 1:1 , 3 , 5]", + "eval.tests.test_whitespace_tolerance.test_space_around_set_commas_equals_compact[Genesis 1:1, 3 , 5]", + "eval.tests.test_whitespace_tolerance.test_space_around_verse_range_dash_equals_compact", + "eval.tests.test_whitespace_tolerance.test_space_beside_verse_colon_yields_single_verse[Genesis 1 : 1]", + "eval.tests.test_whitespace_tolerance.test_space_beside_verse_colon_yields_single_verse[Genesis 1 :1]", + "eval.tests.test_whitespace_tolerance.test_space_beside_verse_colon_yields_single_verse[Genesis 1: 1]", + "eval.tests.test_whitespace_tolerance.test_space_separated_set_first_last_content", + "eval.tests.test_whitespace_tolerance.test_spaced_cross_chapter_range" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli.test_help_from_long_flag_position", + "eval.tests.test_cli.test_help_prints_exact_usage_golden", + "eval.tests.test_cli.test_invalid_flag_A_value_exit_1", + "eval.tests.test_cli.test_invalid_flag_B_value_exit_1", + "eval.tests.test_cli.test_invalid_flag_prints_error_and_exit_1", + "eval.tests.test_cli.test_list_books_exact_golden", + "eval.tests.test_cli.test_list_books_first_entries", + "eval.tests.test_cli.test_list_books_has_john_and_acts", + "eval.tests.test_cli.test_negative_context_value", + "eval.tests.test_cli.test_unparseable_reference_no_output", + "eval.tests.test_combinations.test_chapter_context_overrides_after_context", + "eval.tests.test_combinations.test_chapter_context_overrides_before_context", + "eval.tests.test_combinations.test_chapter_context_overrides_ranges", + "eval.tests.test_combinations.test_chapter_context_overrides_verse_sets", + "eval.tests.test_combinations.test_highlighted_chapter_context_whole_chapter", + "eval.tests.test_combinations.test_highlighted_range_ext_matches_same_as_plain", + "eval.tests.test_combinations.test_highlighted_range_matches_same_as_plain", + "eval.tests.test_combinations.test_highlighted_single_verse_has_one_decoration_each", + "eval.tests.test_combinations.test_highlighted_verse_set_matches_same_as_plain", + "eval.tests.test_combinations.test_highlighted_whole_chapter_underlines_book_once_per_verse", + "eval.tests.test_context.test_context_after_clamps_at_chapter_boundary", + "eval.tests.test_context.test_context_after_clamps_at_data_end", + "eval.tests.test_context.test_context_after_shows_n_verses", + "eval.tests.test_context.test_context_before_clamps_at_chapter_boundary", + "eval.tests.test_context.test_context_before_clamps_at_data_start", + "eval.tests.test_context.test_context_before_shows_n_verses", + "eval.tests.test_context.test_context_both_sides", + "eval.tests.test_context.test_context_chapter_around_first_and_last_verse", + "eval.tests.test_context.test_context_chapter_shows_entire_chapter", + "eval.tests.test_context.test_context_large_before_count_exact", + "eval.tests.test_context.test_context_merges_overlapping_ranges", + "eval.tests.test_context.test_context_search_multiple_separate_matches", + "eval.tests.test_context.test_context_zero_before_after", + "eval.tests.test_context_params.test_context_window_exact[-A_1_Revelation2221]", + "eval.tests.test_context_params.test_context_window_exact[-A_2_John316]", + "eval.tests.test_context_params.test_context_window_exact[-A_2_John31]", + "eval.tests.test_context_params.test_context_window_exact[-A_3_Genesis131]", + "eval.tests.test_context_params.test_context_window_exact[-B_1_-A_1_John316]", + "eval.tests.test_context_params.test_context_window_exact[-B_2_-A_2_Obadiah15]", + "eval.tests.test_context_params.test_context_window_exact[-B_2_Genesis11]", + "eval.tests.test_context_params.test_context_window_exact[-B_2_Genesis21]", + "eval.tests.test_context_params.test_context_window_exact[-B_2_John316]", + "eval.tests.test_context_params.test_context_window_exact[-B_3_John420]", + "eval.tests.test_context_params.test_context_window_merges_adjacent_matches", + "eval.tests.test_exact.test_exact_book_genesis_first_verse", + "eval.tests.test_exact.test_exact_book_obadiah_count", + "eval.tests.test_exact.test_exact_chapter_boundary_verse36_then_next_chapter", + "eval.tests.test_exact.test_exact_chapter_first_and_last_verses_ordered", + "eval.tests.test_exact.test_exact_chapter_psalm23_count", + "eval.tests.test_exact.test_exact_single_verse_book_abbreviation_gen11", + "eval.tests.test_exact.test_exact_single_verse_john11", + "eval.tests.test_exact.test_exact_single_verse_john316", + "eval.tests.test_exact.test_exact_single_verse_last_book", + "eval.tests.test_exact.test_exact_unknown_book_returns_no_verses", + "eval.tests.test_exact.test_exact_unknown_chapter_out_of_range", + "eval.tests.test_exact.test_exact_unknown_verse_out_of_range", + "eval.tests.test_exact_set.test_verse_set_duplicate_member", + "eval.tests.test_exact_set.test_verse_set_members_across_chapters_not_allowed", + "eval.tests.test_exact_set.test_verse_set_out_of_range_member", + "eval.tests.test_exact_set.test_verse_set_single_member", + "eval.tests.test_exact_set.test_verse_set_sparse_members", + "eval.tests.test_exact_set.test_verse_set_two_verses", + "eval.tests.test_exact_set.test_verse_set_unsorted_input_still_array_ordered", + "eval.tests.test_highlight_and_pretty.test_chapter_context_matches_not_required_verses", + "eval.tests.test_highlight_and_pretty.test_chapter_context_obadiah_full_book", + "eval.tests.test_highlight_and_pretty.test_chapter_context_wide_open_psalms", + "eval.tests.test_highlight_and_pretty.test_chapter_context_with_highlighting_count", + "eval.tests.test_highlight_and_pretty.test_highlighting_does_not_remove_context", + "eval.tests.test_highlight_and_pretty.test_highlighting_search_result", + "eval.tests.test_highlight_and_pretty.test_highlighting_wraps_book_and_cv", + "eval.tests.test_highlight_and_pretty.test_no_highlight_when_default_non_tty", + "eval.tests.test_iteration.test_book_header_not_emitted_in_non_pretty", + "eval.tests.test_iteration.test_book_iterates_all_chapters_in_order", + "eval.tests.test_iteration.test_consecutive_verses_are_contiguous", + "eval.tests.test_iteration.test_exact_set_iteration_follows_array_order", + "eval.tests.test_iteration.test_iteration_stops_and_no_trailing_blank", + "eval.tests.test_iteration.test_multiple_books_global_search_order", + "eval.tests.test_iteration.test_search_disjoint_windows_with_context", + "eval.tests.test_iteration.test_search_many_single_windows_sorted", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Chronicles1611]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Corinthians134]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1John48]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Kings35]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Peter57]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Thessalonians516]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[1Timothy612]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Chronicles714]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Corinthians517]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2John11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Kings211]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Peter39]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Samuel222]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Thessalonians33]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[2Timothy17]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[3John11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Acts18]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Amos524]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Colossians323]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Daniel325]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Deuteronomy65]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Ecclesiastes31]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Ephesians28]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Esther217]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Exodus203]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Ezekiel371]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Ezra11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Galatians522]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Genesis11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Genesis12]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Habakkuk24]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Haggai11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Hebrews111]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Hosea111]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Isaiah535]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[James15]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Jeremiah2911]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Job11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Joel228]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[John316]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Jonah117]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Joshua19]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Jude11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Judges531]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Lamentations322]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Leviticus1918]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Luke214]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Malachi310]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Mark11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Matthew59]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Micah68]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Nahum13]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Nehemiah24]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Numbers624]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Obadiah11]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Philemon14]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Philippians413]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Proverbs35]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Psalms231]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Revelation320]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Romans828]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Ruth116]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Titus211]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Zechariah99]", + "eval.tests.test_precise_oracles.test_exact_single_resolves_book_chapter_verse[Zephaniah317]", + "eval.tests.test_precise_oracles.test_range_ext_exact[John1040to112]", + "eval.tests.test_precise_oracles.test_range_ext_exact[John310to314]", + "eval.tests.test_precise_oracles.test_range_ext_exact[John336to41]", + "eval.tests.test_precise_oracles.test_verse_range_exact[Genesis21to3]", + "eval.tests.test_precise_oracles.test_verse_range_exact[John316to18]", + "eval.tests.test_precise_oracles.test_verse_range_exact[Revelation11to3]", + "eval.tests.test_precise_oracles.test_verse_set_exact[Genesis11_31]", + "eval.tests.test_precise_oracles.test_verse_set_exact[John316_18]", + "eval.tests.test_precise_oracles.test_verse_set_exact[John31_36]", + "eval.tests.test_range.test_chapter_range_across_last_chapter_boundary", + "eval.tests.test_range.test_chapter_range_inclusive_count", + "eval.tests.test_range.test_chapter_range_multi_chapter_order", + "eval.tests.test_range.test_chapter_range_single_chapter", + "eval.tests.test_range.test_verse_range_2_verses_verbatim", + "eval.tests.test_range.test_verse_range_extends_to_chapter_end", + "eval.tests.test_range.test_verse_range_single_equal_endpoints", + "eval.tests.test_range.test_verse_range_whole_gap_inclusive", + "eval.tests.test_range.test_verse_range_zero_lower_bound_clamps_to_chapter_start", + "eval.tests.test_range_ext.test_range_ext_across_two_chapters_full", + "eval.tests.test_range_ext.test_range_ext_adjacent_verses", + "eval.tests.test_range_ext.test_range_ext_end_chapter_beyond_real_end", + "eval.tests.test_range_ext.test_range_ext_end_chapter_head_only", + "eval.tests.test_range_ext.test_range_ext_many_middle_chapters_included_wholly", + "eval.tests.test_range_ext.test_range_ext_same_chapter_acts_like_verse_range", + "eval.tests.test_range_ext.test_range_ext_start_beyond_one_end_chapter_only", + "eval.tests.test_range_ext.test_range_ext_start_chapter_tail_only", + "eval.tests.test_reference_form_edges.test_book_abbreviation_prefix_resolves", + "eval.tests.test_reference_form_edges.test_book_only_chapter_reference_whole_chapter", + "eval.tests.test_reference_form_edges.test_chapter_context_over_multichapter_range_ext", + "eval.tests.test_reference_form_edges.test_chapter_range_reference_is_inclusive", + "eval.tests.test_reference_form_edges.test_chapter_range_single_chapter_equals_whole_chapter", + "eval.tests.test_reference_form_edges.test_e_decorates_context_verses_too", + "eval.tests.test_reference_form_edges.test_e_decorates_every_chapter_range_verse", + "eval.tests.test_reference_form_edges.test_range_ext_multi_chapter_inclusive_order", + "eval.tests.test_reference_form_edges.test_range_ext_same_chapter_seam_single_verse", + "eval.tests.test_reference_form_edges.test_regex_end_anchor_global_exact_set", + "eval.tests.test_reference_form_edges.test_regex_end_anchor_no_match_in_chapter", + "eval.tests.test_reference_form_edges.test_w_flag_is_ignored_noop", + "eval.tests.test_search.test_search_abbreviated_book", + "eval.tests.test_search.test_search_anchor_beginning", + "eval.tests.test_search.test_search_book_chapter_filter_exact_set", + "eval.tests.test_search.test_search_book_filter_exact_set", + "eval.tests.test_search.test_search_book_with_no_results", + "eval.tests.test_search.test_search_global_case_insensitive_exact_set", + "eval.tests.test_search.test_search_no_match_returns_empty", + "eval.tests.test_search.test_search_regex_alternation_exact_set", + "eval.tests.test_search.test_search_regex_class_exact_set", + "eval.tests.test_search.test_search_regex_class_literal_digit_rare", + "eval.tests.test_search.test_search_specific_chapter_exact_set", + "eval.tests.test_search_params.test_search_book_filter_global_vs_book", + "eval.tests.test_search_params.test_search_book_filter_restricts_book[Genesis_God]", + "eval.tests.test_search_params.test_search_book_filter_restricts_book[John1_light]", + "eval.tests.test_search_params.test_search_book_filter_restricts_book[John3_eternal]", + "eval.tests.test_search_params.test_search_book_filter_restricts_book[Matthew5_blessed]", + "eval.tests.test_search_params.test_search_exact_count_and_prefix[Genesis_God]", + "eval.tests.test_search_params.test_search_exact_count_and_prefix[John1_light]", + "eval.tests.test_search_params.test_search_exact_count_and_prefix[John3_eternal]", + "eval.tests.test_search_params.test_search_exact_count_and_prefix[Matthew5_blessed]", + "eval.tests.test_search_params.test_search_exact_count_and_prefix[_Moses]", + "eval.tests.test_search_params.test_search_icase_matches_uppercase_text", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/God]", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/LORD]", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/^And]", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/faith]", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/in the beginning]", + "eval.tests.test_search_params.test_search_returns_only_real_verse_lines[/love]", + "eval.tests.test_whole_books.test_chapter_context_ruth_chapter1", + "eval.tests.test_whole_books.test_chapter_range_two_whole_chapters", + "eval.tests.test_whole_books.test_context_across_book_boundary_clamps", + "eval.tests.test_whole_books.test_range_ext_whole_book_span", + "eval.tests.test_whole_books.test_search_anchor_beginning_keeps_prefix", + "eval.tests.test_whole_books.test_search_word_in_book_and_chapter", + "eval.tests.test_whole_books.test_whole_book_iteration_count[3John]", + "eval.tests.test_whole_books.test_whole_book_iteration_count[Haggai]", + "eval.tests.test_whole_books.test_whole_book_iteration_count[Jonah]", + "eval.tests.test_whole_books.test_whole_book_iteration_count[Jude]", + "eval.tests.test_whole_books.test_whole_book_iteration_count[Philemon]", + "eval.tests.test_whole_books.test_whole_book_iteration_count[Ruth]" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_render.test_additional_book_abbreviations_exact[args0-James 1:1 James, a servant of God and of the Lord Jesus Christ, to the twelve tribes which are scattered abroad, greeting.\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Jas:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_additional_book_abbreviations_exact[args1-Exodus 20:3 Thou shalt have no other gods before me.\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Exo:20:3']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_additional_book_abbreviations_exact[args2-Deuteronomy 6:4 Hear, O Israel: The LORD our God is one LORD:\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Deu:6:4']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_additional_book_abbreviations_exact[args3-Amos 3:3 Can two walk together, except they be agreed?\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Amos:3:3']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_book_prefix_pet_does_not_resolve", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Pet:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_exit_zero_for_all_no_match_states", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '/zzzz']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_highlight_after_context_expands_markers", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-e', '-B', '1', '-A', '1', 'Mat:5:14']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_highlight_revelation_long_book_name_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-e', 'Rev:22:21']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_highlight_verse_set_counts_per_verse", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-e', 'Gen:1:7,3']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_longest_chapter_psalm_119_exact_count", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Ps:119']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_W_flag_is_noop_through_pager", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-W', 'Gen:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_chapter_context_shortest_chapter_expands_both", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-C', 'Ps:117:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_context_after_long_chapter_expands_forward", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-A', '2', 'Ps:119:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_context_before_at_chapter_open_no_cross", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-B', '1', 'Gen:2:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_context_chapter_flag_blocks", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-C', 'Mat:5:14']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_cross_book_separator_exact_head", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '/light']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_highlight_chapter_context_shortest_book_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-e', '-C', 'Ps:117:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_list_books_ignores_pager_layout", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-l']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_no_match_kills_child_empty", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', 'NotARealBook']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_pager_runs_with_highlight_flag", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '-e', 'Gen:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_plain_vs_pager_layouts_differ", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Gen:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_search_global_pattern_arg_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '/light']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_search_no_match_empty_exit_zero", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '/znope']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_search_pager_gains_pattern_arg_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', 'Genesis:1/God']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_shortest_chapter_exact_block", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', 'Ps:117']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_two_verse_chapter_blocks_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', 'Gen:2:1-2']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_whole_book_search_headings_count", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '/God']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_pretty_wrapping_session_long_verse", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', '1Cor:13:4']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_romans_sixteen_chapter_count_exact", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Rom:16']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_case_class_count_exact[args0-7]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Genesis:1/[fF]irmament']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_case_class_count_exact[args1-2]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Genesis:1/great']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_case_class_count_exact[args2-5]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Genesis:1/sea']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_case_class_count_exact[args3-1]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Matthew:5/spirit']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_case_insensitive_whole_book_equal", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'John/grace']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_empty_pattern_whole_bible_all_verses", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '/']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_global_spans_multiple_books_exact", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_render.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_scoped_chapter_with_context_expands", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-A', '1', 'Genesis:1/God']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_search_whole_bible_alternation_spans_books", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '/fowl|whale']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_shortest_chapter_psalm_117_two_verses", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Ps:117']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args0-Obadiah 1:1 The vision of Obadiah. Thus saith the Lord GOD concerning Edom; We have heard a rumour from the LORD, and an ambassador is sent among the heathen, Arise ye, and let us rise up against her in battle.\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Obad:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args1-Jude 1:1 Jude, the servant of Jesus Christ, and brother of James, to them that are sanctified by God the Father, and preserved in Jesus Christ, and called:\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Jude:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args2-Philemon 1:1 Paul, a prisoner of Jesus Christ, and Timothy our brother, unto Philemon our dearly beloved, and fellowlabourer,\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Phmn:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args3-2 John 1:1 The elder unto the elect lady and her children, whom I love in the truth; and not I only, but also all they that have known the truth;\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '2Jn:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args4-3 John 1:1 The elder unto the wellbeloved Gaius, whom I love in the truth.\\n]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '3Jn:1:1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_single_chapter_local_range_one_verse", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Gen:1:1-1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_verse_set_descending_normalizes_to_ascending", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Gen:1:7,3,1']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_verse_set_duplicates_within_set_collapse", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Gen:1:1,1,2']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args0-Ruth 1:1 Now it came to pass in the days when the judges ruled, that there was a famine in the land. And a certain man of Bethlehemjudah went to sojourn in the country of Moab, he, and his wife, and his two sons.-Ruth 4:22 And Obed begat Jesse, and Jesse begat David.]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Ruth']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args1-Jonah 1:1 Now the word of the LORD came unto Jonah the son of Amittai, saying,-Jonah 4:11 And should not I spare Nineveh, that great city, wherein are more than sixscore thousand persons that cannot discern between their right hand and their left hand; and also much cattle?]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Jonah']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args2-Habakkuk 1:1 The burden which Habakkuk the prophet did see.-Habakkuk 3:19 The LORD God is my strength, and he will make my feet like hinds' feet, and he will make me to walk upon mine high places. To the chief singer on my stringed instruments.]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Habakkuk']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args3-Titus 1:1 Paul, a servant of God, and an apostle of Jesus Christ, according to the faith of God's elect, and the acknowledging of the truth which is after godliness;-Titus 3:15 All that are with me salute thee. Greet them that love us in the faith. Grace be with you all. Amen.]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', 'Titus']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args4-1 Peter 1:1 Peter, an apostle of Jesus Christ, to the strangers scattered throughout Pontus, Galatia, Cappadocia, Asia, and Bithynia,-1 Peter 5:14 Greet ye one another with a kiss of charity. Peace be with you all that are in Christ Jesus. Amen.]", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '1Peter']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + }, + { + "name": "eval.tests.test_render.test_whole_chapter_longest_psalm_one_heading", + "reasons": [ + { + "detail": "subprocess.TimeoutExpired: Command '['/workspace/golden-2/executable', '-p', 'Ps:119']' timed out after 120 seconds", + "id": "gold_fail", + "message": "test failed against the reference executable", + "repair_hint": "Fix the expected observable behavior so the test passes against the reference executable.", + "severity": "error", + "stage": "gold_execution" + } + ] + } + ], + "tests": [ + "eval.tests.test_render.test_W_flag_is_valid_noop", + "eval.tests.test_render.test_additional_book_abbreviations_exact[args0-James 1:1 James, a servant of God and of the Lord Jesus Christ, to the twelve tribes which are scattered abroad, greeting.\\n]", + "eval.tests.test_render.test_additional_book_abbreviations_exact[args1-Exodus 20:3 Thou shalt have no other gods before me.\\n]", + "eval.tests.test_render.test_additional_book_abbreviations_exact[args2-Deuteronomy 6:4 Hear, O Israel: The LORD our God is one LORD:\\n]", + "eval.tests.test_render.test_additional_book_abbreviations_exact[args3-Amos 3:3 Can two walk together, except they be agreed?\\n]", + "eval.tests.test_render.test_ambiguous_prefix_jn_not_gospel", + "eval.tests.test_render.test_book_name_resolution_exact[args0-Genesis 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args1-Genesis 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args10-John 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args11-Revelation 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args12-Isaiah 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args13-Psalms 23:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args14-The Acts 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args15-Song of Solomon 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args16-1 Samuel 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args17-2 Timothy 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args18-Philippians 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args19-Hebrews 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args2-Genesis 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args3-Genesis 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args4-Genesis 1:1 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args5-Matthew 5:14 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args6-Matthew 5:14 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args7-1 Corinthians 13:4 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args8-1 Corinthians 13:4 ]", + "eval.tests.test_render.test_book_name_resolution_exact[args9-1 John 1:1 ]", + "eval.tests.test_render.test_book_prefix_pet_does_not_resolve", + "eval.tests.test_render.test_chapter_context_flag_expands_whole_chapter", + "eval.tests.test_render.test_chapter_context_gospel_john_chapter_count", + "eval.tests.test_render.test_chapter_context_is_atty_independent_plain", + "eval.tests.test_render.test_chapter_context_short_chapter_first_chapter_acts", + "eval.tests.test_render.test_chapter_context_with_context_flags_redundant", + "eval.tests.test_render.test_chapter_range_spans_contiguously", + "eval.tests.test_render.test_combined_before_after_zero_keeps_selected_set", + "eval.tests.test_render.test_context_after_boundary_keeps_single_line", + "eval.tests.test_render.test_context_after_first_verse_of_book_expands_forward", + "eval.tests.test_render.test_context_after_last_verse_of_bible_keeps_single", + "eval.tests.test_render.test_context_before_after_expansion_exact", + "eval.tests.test_render.test_context_before_captures_preceding_verse", + "eval.tests.test_render.test_context_before_does_not_cross_into_prev_chapter", + "eval.tests.test_render.test_context_before_first_verse_of_book_single", + "eval.tests.test_render.test_context_before_last_verse_of_bible_exact", + "eval.tests.test_render.test_context_only_after_expands_forward", + "eval.tests.test_render.test_context_two_before_two_after_exact_boundaries", + "eval.tests.test_render.test_exit_zero_for_all_no_match_states", + "eval.tests.test_render.test_ext_range_crosses_chapter_boundary", + "eval.tests.test_render.test_ext_range_within_same_chapter_exact", + "eval.tests.test_render.test_help_output_matches_golden", + "eval.tests.test_render.test_help_then_invalid_flag_still_prints_help", + "eval.tests.test_render.test_help_wins_over_reference_argument", + "eval.tests.test_render.test_highlight_after_context_expands_markers", + "eval.tests.test_render.test_highlight_book_change_resets_per_verse", + "eval.tests.test_render.test_highlight_chapter_context_marks_each_verse", + "eval.tests.test_render.test_highlight_range_each_ref_bold_exact", + "eval.tests.test_render.test_highlight_revelation_long_book_name_exact", + "eval.tests.test_render.test_highlight_single_verse_exact", + "eval.tests.test_render.test_highlight_stripped_equals_plain", + "eval.tests.test_render.test_highlight_verse_set_counts_per_verse", + "eval.tests.test_render.test_highlight_verse_set_pair_counts_exact", + "eval.tests.test_render.test_invalid_A_flag_diagnostic_exact", + "eval.tests.test_render.test_invalid_A_flag_partial_number_rejected", + "eval.tests.test_render.test_invalid_B_flag_diagnostic_exact", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args0]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args10]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args11]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args12]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args1]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args2]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args3]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args4]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args5]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args6]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args7]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args8]", + "eval.tests.test_render.test_invalid_answer_references_empty_exit_zero[args9]", + "eval.tests.test_render.test_invalid_flag_before_help_errors_first", + "eval.tests.test_render.test_invalid_flag_value_zero_then_ref_ignored", + "eval.tests.test_render.test_invalid_long_flag_diagnostic_exact", + "eval.tests.test_render.test_invalid_short_flag_diagnostic_exact", + "eval.tests.test_render.test_leading_zero_chapter_verse_normalizes", + "eval.tests.test_render.test_list_books_combined_with_W_flag", + "eval.tests.test_render.test_list_books_combined_with_highlight_flag", + "eval.tests.test_render.test_list_books_ignores_reference_argument", + "eval.tests.test_render.test_list_books_matches_golden", + "eval.tests.test_render.test_longest_chapter_psalm_119_exact_count", + "eval.tests.test_render.test_multiple_positional_args_joined_are_not_two_refs", + "eval.tests.test_render.test_no_highlight_without_tty_flag", + "eval.tests.test_render.test_numbers_chapter_one_count", + "eval.tests.test_render.test_pretty_W_flag_is_noop_through_pager", + "eval.tests.test_render.test_pretty_chapter_context_shortest_chapter_expands_both", + "eval.tests.test_render.test_pretty_chapter_heading_printed_once", + "eval.tests.test_render.test_pretty_context_after_long_chapter_expands_forward", + "eval.tests.test_render.test_pretty_context_before_after_blocks_exact", + "eval.tests.test_render.test_pretty_context_before_at_chapter_open_no_cross", + "eval.tests.test_render.test_pretty_context_chapter_flag_blocks", + "eval.tests.test_render.test_pretty_cross_book_separator_exact_head", + "eval.tests.test_render.test_pretty_highlight_chapter_context_shortest_book_exact", + "eval.tests.test_render.test_pretty_highlight_exact", + "eval.tests.test_render.test_pretty_highlight_wrapping_long_verse_exact", + "eval.tests.test_render.test_pretty_list_books_ignores_pager_layout", + "eval.tests.test_render.test_pretty_no_match_kills_child_empty", + "eval.tests.test_render.test_pretty_pager_runs_with_highlight_flag", + "eval.tests.test_render.test_pretty_plain_vs_pager_layouts_differ", + "eval.tests.test_render.test_pretty_search_global_pattern_arg_exact", + "eval.tests.test_render.test_pretty_search_no_match_empty_exit_zero", + "eval.tests.test_render.test_pretty_search_pager_gains_pattern_arg_exact", + "eval.tests.test_render.test_pretty_shortest_chapter_exact_block", + "eval.tests.test_render.test_pretty_single_verse_exact", + "eval.tests.test_render.test_pretty_two_verse_chapter_blocks_exact", + "eval.tests.test_render.test_pretty_verse_range_blocks_exact", + "eval.tests.test_render.test_pretty_verse_set_only_selected_exact", + "eval.tests.test_render.test_pretty_whole_book_search_headings_count", + "eval.tests.test_render.test_pretty_whole_chapter_all_verse_blocks", + "eval.tests.test_render.test_pretty_whole_chapter_exact_verse_block_count", + "eval.tests.test_render.test_pretty_whole_psalm_heading_once", + "eval.tests.test_render.test_pretty_wrapping_long_verse_exact", + "eval.tests.test_render.test_pretty_wrapping_second_long_verse_exact", + "eval.tests.test_render.test_pretty_wrapping_session_long_verse", + "eval.tests.test_render.test_reference_leading_trailing_whitespace_ignored", + "eval.tests.test_render.test_render_single_verse_plain_exact[args0-Genesis 1:1 In the beginning God created the heaven and the earth.\\n-Genesis]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args1-Psalms 23:1 The LORD is my shepherd; I shall not want.\\n-Psalms 23]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args10-2 Timothy 1:1 Paul, an apostle of Jesus Christ by the will of God, according to the promise of life which is in Christ Jesus,\\n-2 Timothy 1]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args11-Numbers 1:1 And the LORD spake unto Moses in the wilderness of Sinai, in the tabernacle of the congregation, on the first day of the second month, in the second year after they were come out of the land of Egypt, saying,\\n-Numbers 1]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args12-Ephesians 2:8 For by grace are ye saved through faith; and that not of yourselves: it is the gift of God:\\n-Ephesians 2]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args2-John 3:16 For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.\\n-John 3]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args3-Matthew 5:14 Ye are the light of the world. A city that is set on an hill cannot be hid.\\n-Matthew 5]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args4-1 Corinthians 13:4 Charity suffereth long, and is kind; charity envieth not; charity vaunteth not itself, is not puffed up,\\n-1 Corinthians 13]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args5-Proverbs 1:1 The proverbs of Solomon the son of David, king of Israel;\\n-Proverbs 1]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args6-Malachi 4:6 And he shall turn the heart of the fathers to the children, and the heart of the children to their fathers, lest I come and smite the earth with a curse.\\n-Malachi 4]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args7-Revelation 22:21 The grace of our Lord Jesus Christ be with you all. Amen.\\n-Revelation 22]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args8-John 1:1 In the beginning was the Word, and the Word was with God, and the Word was God.\\n-John 1]", + "eval.tests.test_render.test_render_single_verse_plain_exact[args9-1 Samuel 1:1 Now there was a certain man of Ramathaimzophim, of mount Ephraim, and his name was Elkanah, the son of Jeroham, the son of Elihu, the son of Tohu, the son of Zuph, an Ephrathite:\\n-1 Samuel 1]", + "eval.tests.test_render.test_romans_sixteen_chapter_count_exact", + "eval.tests.test_render.test_search_alternation_count_exact", + "eval.tests.test_render.test_search_book_and_chapter_scoped_god_exact", + "eval.tests.test_render.test_search_book_scoped_exact_first_line", + "eval.tests.test_render.test_search_book_scoped_psalms_light_count", + "eval.tests.test_render.test_search_book_scoped_whole_book_count_and_first_line", + "eval.tests.test_render.test_search_case_class_count_exact[args0-7]", + "eval.tests.test_render.test_search_case_class_count_exact[args1-2]", + "eval.tests.test_render.test_search_case_class_count_exact[args2-5]", + "eval.tests.test_render.test_search_case_class_count_exact[args3-1]", + "eval.tests.test_render.test_search_case_insensitive_equivalent", + "eval.tests.test_render.test_search_case_insensitive_whole_book_equal", + "eval.tests.test_render.test_search_char_class_regex_count", + "eval.tests.test_render.test_search_empty_pattern_matches_every_verse_in_book", + "eval.tests.test_render.test_search_empty_pattern_whole_bible_all_verses", + "eval.tests.test_render.test_search_global_spans_multiple_books_exact", + "eval.tests.test_render.test_search_invalid_regex_empty_exit_zero", + "eval.tests.test_render.test_search_invalid_regex_trailing_escape_empty", + "eval.tests.test_render.test_search_line_begin_anchor_whole_bible_count", + "eval.tests.test_render.test_search_no_match_empty_exit_zero", + "eval.tests.test_render.test_search_scoped_chapter_with_context_expands", + "eval.tests.test_render.test_search_verse_end_anchor_count", + "eval.tests.test_render.test_search_whole_bible_alternation_spans_books", + "eval.tests.test_render.test_search_whole_bible_first_and_last_book_named", + "eval.tests.test_render.test_search_whole_bible_love_first_line_exact", + "eval.tests.test_render.test_search_whole_book_john_grace_exact", + "eval.tests.test_render.test_shortest_chapter_psalm_117_two_verses", + "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args0-Obadiah 1:1 The vision of Obadiah. Thus saith the Lord GOD concerning Edom; We have heard a rumour from the LORD, and an ambassador is sent among the heathen, Arise ye, and let us rise up against her in battle.\\n]", + "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args1-Jude 1:1 Jude, the servant of Jesus Christ, and brother of James, to them that are sanctified by God the Father, and preserved in Jesus Christ, and called:\\n]", + "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args2-Philemon 1:1 Paul, a prisoner of Jesus Christ, and Timothy our brother, unto Philemon our dearly beloved, and fellowlabourer,\\n]", + "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args3-2 John 1:1 The elder unto the elect lady and her children, whom I love in the truth; and not I only, but also all they that have known the truth;\\n]", + "eval.tests.test_render.test_single_chapter_books_first_verse_exact[args4-3 John 1:1 The elder unto the wellbeloved Gaius, whom I love in the truth.\\n]", + "eval.tests.test_render.test_single_chapter_local_range_one_verse", + "eval.tests.test_render.test_single_chapter_psalm23_exact_head_and_tail", + "eval.tests.test_render.test_song_of_solomon_single_chapter_book", + "eval.tests.test_render.test_space_tolerant_reference_parse", + "eval.tests.test_render.test_two_verse_range_renders_contiguous", + "eval.tests.test_render.test_verse_set_descending_normalizes_to_ascending", + "eval.tests.test_render.test_verse_set_duplicate_verse_collapses_to_one_line", + "eval.tests.test_render.test_verse_set_duplicates_within_set_collapse", + "eval.tests.test_render.test_verse_set_odd_verse_selection_exact", + "eval.tests.test_render.test_verse_set_renders_only_selected_in_order", + "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args0-Ruth 1:1 Now it came to pass in the days when the judges ruled, that there was a famine in the land. And a certain man of Bethlehemjudah went to sojourn in the country of Moab, he, and his wife, and his two sons.-Ruth 4:22 And Obed begat Jesse, and Jesse begat David.]", + "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args1-Jonah 1:1 Now the word of the LORD came unto Jonah the son of Amittai, saying,-Jonah 4:11 And should not I spare Nineveh, that great city, wherein are more than sixscore thousand persons that cannot discern between their right hand and their left hand; and also much cattle?]", + "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args2-Habakkuk 1:1 The burden which Habakkuk the prophet did see.-Habakkuk 3:19 The LORD God is my strength, and he will make my feet like hinds' feet, and he will make me to walk upon mine high places. To the chief singer on my stringed instruments.]", + "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args3-Titus 1:1 Paul, a servant of God, and an apostle of Jesus Christ, according to the faith of God's elect, and the acknowledging of the truth which is after godliness;-Titus 3:15 All that are with me salute thee. Greet them that love us in the faith. Grace be with you all. Amen.]", + "eval.tests.test_render.test_whole_book_first_and_last_line_exact[args4-1 Peter 1:1 Peter, an apostle of Jesus Christ, to the strangers scattered throughout Pontus, Galatia, Cappadocia, Asia, and Bithynia,-1 Peter 5:14 Greet ye one another with a kiss of charity. Peace be with you all that are in Christ Jesus. Amen.]", + "eval.tests.test_render.test_whole_book_genesis_last_verse_exact", + "eval.tests.test_render.test_whole_book_last_book_last_verse_exact", + "eval.tests.test_render.test_whole_book_psalms_first_line_exact", + "eval.tests.test_render.test_whole_chapter_exact_line_count", + "eval.tests.test_render.test_whole_chapter_longest_psalm_one_heading", + "eval.tests.test_render.test_zero_context_is_passthrough_exact", + "eval.tests.test_render.test_zero_verse_position_renders_full_chapter" + ] + } + }, + "commit": "0b6a9ceb1b768b7ab7e29a06b59fc318ce88cbf0", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 0.9309490311675228, + "eval_clean_hashes": [ + "8525dffbdfb617c83976717c0aeb8b76f18976e94e3a66068b9d7c21053aa5f5" + ], + "input_record": { + "commit": "0b6a9ceb1b768b7ab7e29a06b59fc318ce88cbf0", + "commits": 67, + "contributors": 0, + "difficulty": "easy", + "difficulty_code_lines": 853, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 853, + "difficulty_runtime_deps": 0, + "difficulty_score": 0.9309490311675228, + "difficulty_test_code_lines": 0, + "full_name": "layeh/kjv", + "github_stars": 222, + "input_joern_zip": "c_joern/layeh__kjv.zip", + "joern_status": true, + "joern_time": 15.714128268999048, + "language": "c", + "pb_match": [ + { + "pb_fullname": "php/php-src", + "rank": 701, + "similarity": 0.4252505302429199 + }, + { + "pb_fullname": "jqlang/jq", + "rank": 923, + "similarity": 0.3557485342025757 + }, + { + "pb_fullname": "jonas/tig", + "rank": 451, + "similarity": 0.4565374255180359 + }, + { + "pb_fullname": "ggreer/the_silver_searcher", + "rank": 761, + "similarity": 0.426040381193161 + }, + { + "pb_fullname": "cslarsen/jp2a", + "rank": 693, + "similarity": 0.41261011362075806 + }, + { + "pb_fullname": "jarun/nnn", + "rank": 550, + "similarity": 0.5008979439735413 + }, + { + "pb_fullname": "cmatsuoka/figlet", + "rank": 149, + "similarity": 0.515459418296814 + }, + { + "pb_fullname": "lfos/calcurse", + "rank": 628, + "similarity": 0.41397497057914734 + }, + { + "pb_fullname": "eradman/entr", + "rank": 705, + "similarity": 0.3931197226047516 + }, + { + "pb_fullname": "hpjansson/chafa", + "rank": 381, + "similarity": 0.4759920835494995 + }, + { + "pb_fullname": "xorg62/tty-clock", + "rank": 635, + "similarity": 0.38770362734794617 + } + ], + "repo_age": 7.99, + "repo_path": "c/layeh__kjv", + "source": "commit:0b6a9ceb1b768b7ab7e29a06b59fc318ce88cbf0", + "status": "done", + "url": "https://github.com/layeh/kjv" + }, + "instance_id": "layeh__kjv.0b6a9ce", + "language": "c", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 3, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "early_stopping" + } + ], + "repository": "layeh/kjv" +} diff --git a/layeh--kjv.0b6a9ce/tests/test.sh b/layeh--kjv.0b6a9ce/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/layeh--kjv.0b6a9ce/tests/workspace.tar.gz b/layeh--kjv.0b6a9ce/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9a2151fdddbbcc2a447aabe9954998371acd493d --- /dev/null +++ b/layeh--kjv.0b6a9ce/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76406bef778d76a64ff4f939ffabee5cfee92d50db7899756c44db9ee6f0813b +size 1664761 diff --git a/lazytiger--gumbo-query.9a269cd/environment/Dockerfile b/lazytiger--gumbo-query.9a269cd/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/lazytiger--gumbo-query.9a269cd/environment/docker-compose.yaml b/lazytiger--gumbo-query.9a269cd/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lazytiger--gumbo-query.9a269cd/environment/download.sh b/lazytiger--gumbo-query.9a269cd/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..0eb991ca63f98cec9509670200336bcc8ede5575 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/download.sh @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +# download.sh for gumbo-query (C++). +# Installs the missing system build dependency and leaves no repo-file reads. +# Source-safe: intended to be run via `source /source_ro/download.sh` from the repo root. +# It performs PRE-FETCH ONLY: it installs system packages and must not compile, +# link, configure, or test anything. + +set -e + +# Refresh the apt package lists (network is available during this stage). +apt-get update + +# The example target links against Google's Gumbo HTML5 parser. The base image +# (Ubuntu 22.04) ships g++/make/cmake but does NOT provide <gumbo.h>/libgumbo. +# Install the dev package so gumbo-query sources and example can build offline +# during the build.sh stage: +# - libgumbo-dev : provides /usr/include/gumbo.h and /usr/lib/.../libgumbo.{a,so} +# - libgumbo1 : pulled in as a dependency; provides the runtime shared lib +apt-get install -y libgumbo-dev + +# No build steps here. build.sh will compile using the toolchain already present. diff --git a/lazytiger--gumbo-query.9a269cd/environment/executable b/lazytiger--gumbo-query.9a269cd/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..91fbfb80decafcb668a3f7fd893e26b3752b30b9 Binary files /dev/null and b/lazytiger--gumbo-query.9a269cd/environment/executable differ diff --git a/lazytiger--gumbo-query.9a269cd/environment/harbor_configure_apt_mirror.sh b/lazytiger--gumbo-query.9a269cd/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lazytiger--gumbo-query.9a269cd/environment/harbor_prepare_download_env.sh b/lazytiger--gumbo-query.9a269cd/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lazytiger--gumbo-query.9a269cd/environment/workspace.tar.gz b/lazytiger--gumbo-query.9a269cd/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..47ec6bf0b8e69953956f6c328c1c5b27412a8eb6 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c801810ecbda6e312df5a40305c861dfb867c1f73c9c6ff1f1bc1654cfcf85d +size 787 diff --git a/lazytiger--gumbo-query.9a269cd/instruction.md b/lazytiger--gumbo-query.9a269cd/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/lazytiger--gumbo-query.9a269cd/solution/solve.sh b/lazytiger--gumbo-query.9a269cd/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/lazytiger--gumbo-query.9a269cd/task.toml b/lazytiger--gumbo-query.9a269cd/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e9c55aba05344225b2cfd1441213eb487cbeca00 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/lazytiger--gumbo-query.9a269cd" +description = "Synthetic ProgramGym cleanroom reconstruction task for lazytiger/gumbo-query" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "lazytiger__gumbo-query.9a269cd" +repository = "lazytiger/gumbo-query" +commit = "9a269cd94caa32f6d3ee7a203d87bdebc7d38978" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.8752349464501652 +test_branches = 2 +test_count = 130 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/lazytiger--gumbo-query.9a269cd/tests/Dockerfile b/lazytiger--gumbo-query.9a269cd/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_01.tar.gz b/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2c8c50e9e34b6032a196113fd5bafa3465b22946 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ec62e5aec9d40465fcc4dae3db73e226425d1d694cddfccb5c1bec94e0f6618 +size 8503 diff --git a/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_02.tar.gz b/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..abe2d47460d58c88a8ec867be550615e664aaa71 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d765795c79293988c9b15e5f99c25f166fae11cada8aaa48861b550d68bd2f77 +size 10246 diff --git a/lazytiger--gumbo-query.9a269cd/tests/docker-compose.yaml b/lazytiger--gumbo-query.9a269cd/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lazytiger--gumbo-query.9a269cd/tests/download.sh b/lazytiger--gumbo-query.9a269cd/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..0eb991ca63f98cec9509670200336bcc8ede5575 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/download.sh @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +# download.sh for gumbo-query (C++). +# Installs the missing system build dependency and leaves no repo-file reads. +# Source-safe: intended to be run via `source /source_ro/download.sh` from the repo root. +# It performs PRE-FETCH ONLY: it installs system packages and must not compile, +# link, configure, or test anything. + +set -e + +# Refresh the apt package lists (network is available during this stage). +apt-get update + +# The example target links against Google's Gumbo HTML5 parser. The base image +# (Ubuntu 22.04) ships g++/make/cmake but does NOT provide <gumbo.h>/libgumbo. +# Install the dev package so gumbo-query sources and example can build offline +# during the build.sh stage: +# - libgumbo-dev : provides /usr/include/gumbo.h and /usr/lib/.../libgumbo.{a,so} +# - libgumbo1 : pulled in as a dependency; provides the runtime shared lib +apt-get install -y libgumbo-dev + +# No build steps here. build.sh will compile using the toolchain already present. diff --git a/lazytiger--gumbo-query.9a269cd/tests/executable b/lazytiger--gumbo-query.9a269cd/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..91fbfb80decafcb668a3f7fd893e26b3752b30b9 Binary files /dev/null and b/lazytiger--gumbo-query.9a269cd/tests/executable differ diff --git a/lazytiger--gumbo-query.9a269cd/tests/harbor_configure_apt_mirror.sh b/lazytiger--gumbo-query.9a269cd/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lazytiger--gumbo-query.9a269cd/tests/harbor_prepare_download_env.sh b/lazytiger--gumbo-query.9a269cd/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lazytiger--gumbo-query.9a269cd/tests/programgym_evaluator.py b/lazytiger--gumbo-query.9a269cd/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/lazytiger--gumbo-query.9a269cd/tests/programgym_task.json b/lazytiger--gumbo-query.9a269cd/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..25477afad3b23c3af6db7a0552def17b96fa7aea --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/programgym_task.json @@ -0,0 +1,241 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_executable_parser.test_batch_stdin_multiple_payloads_identical", + "eval.tests.test_executable_parser.test_content_region_delimiters_are_first_and_last_bytes", + "eval.tests.test_executable_parser.test_div_content_region_inner_bytes_exact", + "eval.tests.test_executable_parser.test_div_region_contains_both_text_nodes_in_order", + "eval.tests.test_executable_parser.test_empty_and_whitespace_arguments_ignored", + "eval.tests.test_executable_parser.test_escape_attribute_query_emits_inner_text", + "eval.tests.test_executable_parser.test_escape_attribute_query_region_closes", + "eval.tests.test_executable_parser.test_escape_content_region_inner_bytes_exact", + "eval.tests.test_executable_parser.test_every_printf_record_is_labeled_node", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[a --key=value flag]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[a positional selector-looking argument]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[a short flag with a value]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[end-of-options marker]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[help flag]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[multiple positional arguments]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[short help flag]", + "eval.tests.test_executable_parser.test_exit_code_and_output_zero_regardless_of_arguments[version flag]", + "eval.tests.test_executable_parser.test_exit_code_is_success_with_output", + "eval.tests.test_executable_parser.test_first_pair_differs_from_html_region", + "eval.tests.test_executable_parser.test_four_printf_records_present_in_order", + "eval.tests.test_executable_parser.test_full_stdout_equals_expected_records", + "eval.tests.test_executable_parser.test_full_stdout_equals_golden", + "eval.tests.test_executable_parser.test_help_flag_does_not_print_help", + "eval.tests.test_executable_parser.test_html_div_region_closes_with_delimiter", + "eval.tests.test_executable_parser.test_html_div_region_contains_closing_span", + "eval.tests.test_executable_parser.test_html_div_type_selector_emits_span_region", + "eval.tests.test_executable_parser.test_html_region_distinct_from_escape_region", + "eval.tests.test_executable_parser.test_inner_text_records_have_no_content_delimiter", + "eval.tests.test_executable_parser.test_many_positional_arguments_ignored", + "eval.tests.test_executable_parser.test_observed_and_golden_payloads_agree_exactly", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[a --key=value flag]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[a positional selector-looking argument]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[a short flag with a value]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[end-of-options marker]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[help flag]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[multiple positional arguments]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[short help flag]", + "eval.tests.test_executable_parser.test_output_identical_regardless_of_arguments[version flag]", + "eval.tests.test_executable_parser.test_output_identical_when_config_home_cleared", + "eval.tests.test_executable_parser.test_output_identical_when_locale_environment_cleared", + "eval.tests.test_executable_parser.test_output_identical_when_stdin_is_empty", + "eval.tests.test_executable_parser.test_output_identical_when_stdin_is_html", + "eval.tests.test_executable_parser.test_output_identical_when_stdin_is_large", + "eval.tests.test_executable_parser.test_output_is_deterministic_across_runs", + "eval.tests.test_executable_parser.test_output_same_when_run_from_clean_cwd", + "eval.tests.test_executable_parser.test_parser_descendant_and_class_dedup", + "eval.tests.test_executable_parser.test_parser_descendant_class_query_content", + "eval.tests.test_executable_parser.test_parser_descendant_class_query_text", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[a single empty-string argument]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[combinator punctuation as args]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[multibyte unicode content in an arg]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[parenthesized pseudoclass args]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[pseudoclass selectors after --]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[raw HTML passed as an argument]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[selectors after end-of-options marker]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_are_ignored[whitespace/control characters in an arg]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[a single empty-string argument]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[combinator punctuation as args]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[multibyte unicode content in an arg]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[parenthesized pseudoclass args]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[pseudoclass selectors after --]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[raw HTML passed as an argument]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[selectors after end-of-options marker]", + "eval.tests.test_executable_parser.test_selector_shaped_arguments_do_not_crash[whitespace/control characters in an arg]", + "eval.tests.test_executable_parser.test_span_and_div_regions_do_not_share_bytes", + "eval.tests.test_executable_parser.test_stderr_is_empty", + "eval.tests.test_executable_parser.test_stdin_data_not_echoed", + "eval.tests.test_executable_parser.test_stdout_identical_when_stdout_is_a_pipe_or_file", + "eval.tests.test_executable_parser.test_stdout_is_valid_utf8_record_set", + "eval.tests.test_executable_parser.test_stdout_length_is_exactly_69_bytes", + "eval.tests.test_executable_parser.test_under_and_over_typical_argc_boundaries" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_document_node.test_closed_stdout_and_stderr_handles_still_exit_zero", + "reasons": [ + { + "id": "sole_returncode", + "message": "pytest test only asserts returncode == 0", + "path": "eval/tests/test_document_node.py", + "repair_hint": "Check stdout, stderr, generated files, or structured output in addition to exit code.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "all_assertions_weak", + "message": "pytest test uses only weak assertions", + "path": "eval/tests/test_document_node.py", + "repair_hint": "Add at least one semantic oracle over concrete output, files, schema, or state.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_document_node.test_closed_stdout_and_stderr_handles_still_exit_zero", + "eval.tests.test_document_node.test_concatenated_sections_rebuild_the_whole_stream", + "eval.tests.test_document_node.test_cwd_is_irrelevant_to_output", + "eval.tests.test_document_node.test_document_find_emits_exactly_four_node_markers", + "eval.tests.test_document_node.test_each_run_returns_zero_and_golden_stream", + "eval.tests.test_document_node.test_each_section_has_an_exact_byte_width", + "eval.tests.test_document_node.test_escape_id_attribute_drives_the_slice", + "eval.tests.test_document_node.test_escape_section_is_exactly_two_lines", + "eval.tests.test_document_node.test_escape_selector_matches_the_quoted_id", + "eval.tests.test_document_node.test_escape_span_slice_is_inner_text_only", + "eval.tests.test_document_node.test_every_line_matches_its_golden_counterpart", + "eval.tests.test_document_node.test_exit_zero_with_exact_golden_stdout", + "eval.tests.test_document_node.test_extra_argv_does_not_change_output", + "eval.tests.test_document_node.test_extra_argv_still_exits_zero", + "eval.tests.test_document_node.test_first_line_reports_parser_anchor_text", + "eval.tests.test_document_node.test_golden_stream_has_exact_total_byte_width_69", + "eval.tests.test_document_node.test_html_and_escape_sections_are_contiguous", + "eval.tests.test_document_node.test_html_div_endpos_excludes_the_closing_div_tag", + "eval.tests.test_document_node.test_html_div_inner_slice_keeps_the_text_node_two", + "eval.tests.test_document_node.test_html_div_inner_slice_starts_at_span", + "eval.tests.test_document_node.test_html_div_slice_spans_the_exact_three_lines", + "eval.tests.test_document_node.test_html_section_is_exactly_three_consecutive_lines", + "eval.tests.test_document_node.test_html_span_and_wrapper_markers_are_preserved_in_slice", + "eval.tests.test_document_node.test_ignored_stdin_cannot_supply_a_document", + "eval.tests.test_document_node.test_last_line_is_the_escaped_span_fragment_marker", + "eval.tests.test_document_node.test_ld_library_path_is_not_required", + "eval.tests.test_document_node.test_ld_library_path_removed_still_exits_zero", + "eval.tests.test_document_node.test_locale_c_environment_reproduces_golden_stream", + "eval.tests.test_document_node.test_merged_fd_reproduces_golden_with_no_extra_stderr_bytes", + "eval.tests.test_document_node.test_node_markers_appear_only_where_formatting_emits_them", + "eval.tests.test_document_node.test_outer_container_closing_tags_never_appear_in_the_stream", + "eval.tests.test_document_node.test_outer_wrapper_closing_markup_is_absent_from_the_stream", + "eval.tests.test_document_node.test_parser_and_html_sections_are_contiguous", + "eval.tests.test_document_node.test_parser_does_not_leak_the_unselected_anchor", + "eval.tests.test_document_node.test_parser_emits_two_node_prefixed_leading_lines", + "eval.tests.test_document_node.test_parser_first_two_lines_are_the_same_text", + "eval.tests.test_document_node.test_parser_section_is_exactly_two_some_link_lines", + "eval.tests.test_document_node.test_parser_text_and_offset_slice_agree", + "eval.tests.test_document_node.test_redirected_stderr_file_is_exactly_empty_and_stdout_file_is_golden", + "eval.tests.test_document_node.test_redirected_stdout_reproduces_golden_bytes_in_file", + "eval.tests.test_document_node.test_second_line_reports_parser_offset_slice", + "eval.tests.test_document_node.test_some_link_is_confined_to_the_two_leading_parser_lines", + "eval.tests.test_document_node.test_stderr_is_exactly_empty", + "eval.tests.test_document_node.test_stdin_payload_does_not_change_output", + "eval.tests.test_document_node.test_stdin_payload_still_exits_zero", + "eval.tests.test_document_node.test_stdout_ends_with_a_final_newline", + "eval.tests.test_document_node.test_stdout_has_exactly_seven_lines_and_each_line_is_golden", + "eval.tests.test_document_node.test_stdout_is_nonempty_and_exactly_golden", + "eval.tests.test_document_node.test_stdout_is_strictly_plain_ascii", + "eval.tests.test_document_node.test_stdout_matches_golden_byte_for_byte", + "eval.tests.test_document_node.test_stdout_total_length_matches_golden", + "eval.tests.test_document_node.test_stdout_uses_no_carriage_returns", + "eval.tests.test_document_node.test_stdout_utf8_bytes_equal_golden_bytes", + "eval.tests.test_document_node.test_three_consecutive_runs_reproduce_the_same_golden_stream", + "eval.tests.test_document_node.test_two_runs_emit_identical_bytes", + "eval.tests.test_document_node.test_two_runs_emit_identical_stdout", + "eval.tests.test_document_node.test_unselected_anchor_word_never_appears_in_any_output", + "eval.tests.test_document_node.test_utf8_environment_locale_reproduces_golden_stream", + "eval.tests.test_document_node.test_utf8_roundtrip_is_lossless", + "eval.tests.test_document_node.test_utf8_stdin_is_ignored" + ] + } + }, + "commit": "9a269cd94caa32f6d3ee7a203d87bdebc7d38978", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.8752349464501652, + "eval_clean_hashes": [ + "87b4dc8753e6dc8b1eb89de0abab90148795de67f124edbf5680f65759644398" + ], + "input_record": { + "commit": "9a269cd94caa32f6d3ee7a203d87bdebc7d38978", + "difficulty": "easy", + "difficulty_code_lines": 2501, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 2501, + "difficulty_runtime_deps": 2, + "difficulty_score": 1.8752349464501652, + "difficulty_test_code_lines": 103, + "full_name": "lazytiger/gumbo-query", + "input_joern_zip": "cpp_joern/lazytiger__gumbo-query.zip", + "joern_status": true, + "joern_time": 8.293137626955286, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "duckdb/duckdb", + "rank": 570, + "similarity": 0.4440363645553589 + } + ], + "repo_path": "cpp/lazytiger__gumbo-query", + "source": "commit:9a269cd94caa32f6d3ee7a203d87bdebc7d38978", + "status": "done", + "url": "https://github.com/lazytiger/gumbo-query" + }, + "instance_id": "lazytiger__gumbo-query.9a269cd", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "lazytiger/gumbo-query" +} diff --git a/lazytiger--gumbo-query.9a269cd/tests/test.sh b/lazytiger--gumbo-query.9a269cd/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/lazytiger--gumbo-query.9a269cd/tests/workspace.tar.gz b/lazytiger--gumbo-query.9a269cd/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..47ec6bf0b8e69953956f6c328c1c5b27412a8eb6 --- /dev/null +++ b/lazytiger--gumbo-query.9a269cd/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c801810ecbda6e312df5a40305c861dfb867c1f73c9c6ff1f1bc1654cfcf85d +size 787 diff --git a/lbcb-sci--racon.a2cfcac/environment/Dockerfile b/lbcb-sci--racon.a2cfcac/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ea5dabd15b163b4b12b41d1994ffda06041df226 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/Dockerfile @@ -0,0 +1,66 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/lbcb-sci--racon.a2cfcac/environment/docker-compose.yaml b/lbcb-sci--racon.a2cfcac/environment/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lbcb-sci--racon.a2cfcac/environment/download.sh b/lbcb-sci--racon.a2cfcac/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..10cc9e56a67c2f07d763f62942a71c6f4ae1ea42 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/download.sh @@ -0,0 +1,80 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym offline dependency prefetch for racon (lbcb-sci/racon) +# +# This stage runs WITH network access and must be standalone (it does not read +# any repository file). It prepares every dependency that build.sh needs so the +# offline build stage can compile racon without touching the network: +# * zlib1g-dev (zlib headers: racon and bioparser link against zlib) +# * the four CMake FetchContent sources that racon's CMakeLists declares: +# - bioparser (GIT_TAG 3.0.15) +# - edlib (GIT_TAG v1.2.7) +# - spoa (GIT_TAG 4.0.8) +# - thread_pool (GIT_TAG 4.0.0) +# +# These are cloned into a directory that persists into the offline build stage +# (the same container). Environment variables are exported so build.sh can also +# pick them up if the two stages share shell state. +# +# download.sh only downloads / preps dependencies and exports environment. It +# does not configure, compile, link, or test anything. + +# Directory where prefetched dependency sources live. +RACON_DEPS_DIR="${RACON_DEPS_DIR:-/workspace/racon_deps}" + +RACON_BIOPARSER_DIR="${RACON_DEPS_DIR}/bioparser" +RACON_EDLIB_DIR="${RACON_DEPS_DIR}/edlib" +RACON_SPOA_DIR="${RACON_DEPS_DIR}/spoa" +RACON_THREAD_POOL_DIR="${RACON_DEPS_DIR}/thread_pool" + +export RACON_DEPS_DIR +export RACON_BIOPARSER_DIR +export RACON_EDLIB_DIR +export RACON_SPOA_DIR +export RACON_THREAD_POOL_DIR + +# Fail cleanly whether download.sh is sourced or executed directly. +fail() { + echo "[download.sh] ERROR: ${1}" >&2 + if [ "${BASH_SOURCE[0]}" != "${0}" ]; then + return 1 + else + exit 1 + fi +} + +mkdir -p "${RACON_DEPS_DIR}" || fail "cannot create dependency dir ${RACON_DEPS_DIR}" + +# --- System dependency: zlib development headers --------------------------- +if [ ! -f /usr/include/zlib.h ]; then + echo "[download.sh] Installing zlib1g-dev" + if ! apt-get update; then + fail "apt-get update failed" + fi + if ! apt-get install -y zlib1g-dev; then + fail "apt-get install zlib1g-dev failed" + fi +else + echo "[download.sh] zlib1g-dev already present" +fi + +# --- FetchContent dependency sources --------------------------------------- +clone_dep() { + local url="${1}" + local branch="${2}" + local dest="${3}" + if [ -d "${dest}/.git" ]; then + echo "[download.sh] ${dest} already populated, skipping clone" + return 0 + fi + echo "[download.sh] Cloning ${url} (branch ${branch}) -> ${dest}" + if ! git clone --depth 1 --branch "${branch}" "${url}" "${dest}"; then + fail "failed to clone ${url} (branch ${branch})" + fi +} + +clone_dep "https://github.com/rvaser/bioparser" "3.0.15" "$RACON_BIOPARSER_DIR" +clone_dep "https://github.com/martinsos/edlib" "v1.2.7" "$RACON_EDLIB_DIR" +clone_dep "https://github.com/rvaser/spoa" "4.0.8" "$RACON_SPOA_DIR" +clone_dep "https://github.com/rvaser/thread_pool" "4.0.0" "$RACON_THREAD_POOL_DIR" + +echo "[download.sh] Dependency prefetch complete (RACON_DEPS_DIR=${RACON_DEPS_DIR})" diff --git a/lbcb-sci--racon.a2cfcac/environment/executable b/lbcb-sci--racon.a2cfcac/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..997d64891f419fb64a5bb50402190ecccc943404 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe32411d67dbad24e8f25fac9c2c151a942ed3b20363d786d793fbcb0bb200a0 +size 383928 diff --git a/lbcb-sci--racon.a2cfcac/environment/harbor_configure_apt_mirror.sh b/lbcb-sci--racon.a2cfcac/environment/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lbcb-sci--racon.a2cfcac/environment/harbor_prepare_download_env.sh b/lbcb-sci--racon.a2cfcac/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lbcb-sci--racon.a2cfcac/environment/workspace.tar.gz b/lbcb-sci--racon.a2cfcac/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1a3e2527797fb06c26d9be6076081da7555b11b6 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e9347a36c7f8bbde446b00e7acf4d52292ec2b669e3d6c4f0c81297f01eed09 +size 4200 diff --git a/lbcb-sci--racon.a2cfcac/instruction.md b/lbcb-sci--racon.a2cfcac/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/lbcb-sci--racon.a2cfcac/solution/solve.sh b/lbcb-sci--racon.a2cfcac/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/lbcb-sci--racon.a2cfcac/task.toml b/lbcb-sci--racon.a2cfcac/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..17747c345684c1fdafaa61e31883812600292478 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/lbcb-sci--racon.a2cfcac" +description = "Synthetic ProgramGym cleanroom reconstruction task for lbcb-sci/racon" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "lbcb-sci__racon.a2cfcac" +repository = "lbcb-sci/racon" +commit = "a2cfcac281d312a73912a97d6d960404f516c389" +language = "cpp" +difficulty = "medium" +difficulty_score = 2.509336958017644 +test_branches = 7 +test_count = 641 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/lbcb-sci--racon.a2cfcac/tests/Dockerfile b/lbcb-sci--racon.a2cfcac/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..31c24423705b4d9f115d86d6c410e4b65f06031b --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/Dockerfile @@ -0,0 +1,74 @@ +FROM ubuntu:22.04 +ARG PROGRAMGYM_APT_REPOSITORY_BASE_URL="" +ARG PROGRAMGYM_GOPROXY="https://proxy.golang.org,direct" +ARG PROGRAMGYM_NPM_REGISTRY="https://registry.npmjs.org/" +ARG PROGRAMGYM_NPM_STRICT_SSL="true" +ARG PROGRAMGYM_PYPI_INDEX_URL="https://pypi.org/simple" +ARG PROGRAMGYM_PYPI_TRUSTED_HOST="" +ARG PROGRAMGYM_UV_INSECURE_HOST="" +ENV GOPROXY=${PROGRAMGYM_GOPROXY} +ENV PIP_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PROGRAMGYM_PYPI_TRUSTED_HOST} +ENV UV_INDEX_URL=${PROGRAMGYM_PYPI_INDEX_URL} +ENV UV_INSECURE_HOST=${PROGRAMGYM_UV_INSECURE_HOST} +ENV npm_config_registry=${PROGRAMGYM_NPM_REGISTRY} +ENV npm_config_strict_ssl=${PROGRAMGYM_NPM_STRICT_SSL} +COPY harbor_configure_apt_mirror.sh /tmp/harbor_configure_apt_mirror.sh +RUN chmod 0755 /tmp/harbor_configure_apt_mirror.sh \ + && /bin/bash /tmp/harbor_configure_apt_mirror.sh "${PROGRAMGYM_APT_REPOSITORY_BASE_URL}" \ + && rm -f /tmp/harbor_configure_apt_mirror.sh +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_cache=/workspace/.cache/npm +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_01.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c6f093e6962f67b0b7b00c5c402e07d10a5b190e --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7ffa984979ce2385840c53af11525cfa42dbf9fb1383ef339c491996ba8f89a +size 3069520 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_02.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8b5cdcd311310a8c453c6b22a78816ef5c34aa4d --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e5ceb3e34bd435e4d1933844aaecc95aa9dc31484e280412b09be8ba1ee58c6 +size 2761202 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_03.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..94fa0669106c4061df08e02ad5a591ccfe94ce93 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1fd4095d900ffd0c906f682bf71f89641f54f0b2c8f9e57765911f4300a4de44 +size 20361 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_04.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..be3fc16996b6882894904d48d77eb800161ba4ce --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3384d0185a409428865df14ac028f8571163870adac2907e45974d2bdf280c2f +size 17894 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_05.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_05.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3e8cd0d2799ee48cf97b6598b53a4a624072e29f --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_05.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5affd434b9aa4802a5285163927d192c5787f48451d643c687ffea979c20b196 +size 3075924 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_06.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_06.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e5f4aa708bedf8e75941c0a5c5c2f90670cdf8dc --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_module_06.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dca9f6449c2ba0b667b4fcddbcf50adc02ffc788d62927e00b27ee4aee367864 +size 2417936 diff --git a/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_upstream.tar.gz b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_upstream.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..46af5dee8be7e5cebc2b4747d8386594ec628ae6 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/blobs/tests/generated_upstream.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7a6f415f3cf67c45f0ce902dd78191e79405fd2bed36e89654f9046a596e20c9 +size 3054683 diff --git a/lbcb-sci--racon.a2cfcac/tests/docker-compose.yaml b/lbcb-sci--racon.a2cfcac/tests/docker-compose.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f3bd71ea40d31cf72c3c886f85cbca1450add2cc --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/docker-compose.yaml @@ -0,0 +1,11 @@ +services: + main: + build: + args: + PROGRAMGYM_APT_REPOSITORY_BASE_URL: ${PROGRAMGYM_APT_REPOSITORY_BASE_URL:-} + PROGRAMGYM_GOPROXY: ${PROGRAMGYM_GOPROXY:-https://proxy.golang.org,direct} + PROGRAMGYM_NPM_REGISTRY: ${PROGRAMGYM_NPM_REGISTRY:-https://registry.npmjs.org/} + PROGRAMGYM_NPM_STRICT_SSL: ${PROGRAMGYM_NPM_STRICT_SSL:-true} + PROGRAMGYM_PYPI_INDEX_URL: ${PROGRAMGYM_PYPI_INDEX_URL:-https://pypi.org/simple} + PROGRAMGYM_PYPI_TRUSTED_HOST: ${PROGRAMGYM_PYPI_TRUSTED_HOST:-} + PROGRAMGYM_UV_INSECURE_HOST: ${PROGRAMGYM_UV_INSECURE_HOST:-} diff --git a/lbcb-sci--racon.a2cfcac/tests/download.sh b/lbcb-sci--racon.a2cfcac/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..10cc9e56a67c2f07d763f62942a71c6f4ae1ea42 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/download.sh @@ -0,0 +1,80 @@ +#!/usr/bin/env bash +# download.sh - ProgramGym offline dependency prefetch for racon (lbcb-sci/racon) +# +# This stage runs WITH network access and must be standalone (it does not read +# any repository file). It prepares every dependency that build.sh needs so the +# offline build stage can compile racon without touching the network: +# * zlib1g-dev (zlib headers: racon and bioparser link against zlib) +# * the four CMake FetchContent sources that racon's CMakeLists declares: +# - bioparser (GIT_TAG 3.0.15) +# - edlib (GIT_TAG v1.2.7) +# - spoa (GIT_TAG 4.0.8) +# - thread_pool (GIT_TAG 4.0.0) +# +# These are cloned into a directory that persists into the offline build stage +# (the same container). Environment variables are exported so build.sh can also +# pick them up if the two stages share shell state. +# +# download.sh only downloads / preps dependencies and exports environment. It +# does not configure, compile, link, or test anything. + +# Directory where prefetched dependency sources live. +RACON_DEPS_DIR="${RACON_DEPS_DIR:-/workspace/racon_deps}" + +RACON_BIOPARSER_DIR="${RACON_DEPS_DIR}/bioparser" +RACON_EDLIB_DIR="${RACON_DEPS_DIR}/edlib" +RACON_SPOA_DIR="${RACON_DEPS_DIR}/spoa" +RACON_THREAD_POOL_DIR="${RACON_DEPS_DIR}/thread_pool" + +export RACON_DEPS_DIR +export RACON_BIOPARSER_DIR +export RACON_EDLIB_DIR +export RACON_SPOA_DIR +export RACON_THREAD_POOL_DIR + +# Fail cleanly whether download.sh is sourced or executed directly. +fail() { + echo "[download.sh] ERROR: ${1}" >&2 + if [ "${BASH_SOURCE[0]}" != "${0}" ]; then + return 1 + else + exit 1 + fi +} + +mkdir -p "${RACON_DEPS_DIR}" || fail "cannot create dependency dir ${RACON_DEPS_DIR}" + +# --- System dependency: zlib development headers --------------------------- +if [ ! -f /usr/include/zlib.h ]; then + echo "[download.sh] Installing zlib1g-dev" + if ! apt-get update; then + fail "apt-get update failed" + fi + if ! apt-get install -y zlib1g-dev; then + fail "apt-get install zlib1g-dev failed" + fi +else + echo "[download.sh] zlib1g-dev already present" +fi + +# --- FetchContent dependency sources --------------------------------------- +clone_dep() { + local url="${1}" + local branch="${2}" + local dest="${3}" + if [ -d "${dest}/.git" ]; then + echo "[download.sh] ${dest} already populated, skipping clone" + return 0 + fi + echo "[download.sh] Cloning ${url} (branch ${branch}) -> ${dest}" + if ! git clone --depth 1 --branch "${branch}" "${url}" "${dest}"; then + fail "failed to clone ${url} (branch ${branch})" + fi +} + +clone_dep "https://github.com/rvaser/bioparser" "3.0.15" "$RACON_BIOPARSER_DIR" +clone_dep "https://github.com/martinsos/edlib" "v1.2.7" "$RACON_EDLIB_DIR" +clone_dep "https://github.com/rvaser/spoa" "4.0.8" "$RACON_SPOA_DIR" +clone_dep "https://github.com/rvaser/thread_pool" "4.0.0" "$RACON_THREAD_POOL_DIR" + +echo "[download.sh] Dependency prefetch complete (RACON_DEPS_DIR=${RACON_DEPS_DIR})" diff --git a/lbcb-sci--racon.a2cfcac/tests/executable b/lbcb-sci--racon.a2cfcac/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..997d64891f419fb64a5bb50402190ecccc943404 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe32411d67dbad24e8f25fac9c2c151a942ed3b20363d786d793fbcb0bb200a0 +size 383928 diff --git a/lbcb-sci--racon.a2cfcac/tests/harbor_configure_apt_mirror.sh b/lbcb-sci--racon.a2cfcac/tests/harbor_configure_apt_mirror.sh new file mode 100644 index 0000000000000000000000000000000000000000..c70a651096880dece7733b26837f2ca8e24d2c7f --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/harbor_configure_apt_mirror.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +repository_base="${1%/}" +if [[ -z "$repository_base" ]]; then + exit 0 +fi + +. /etc/os-release +codename="${VERSION_CODENAME:-}" +if [[ -z "$codename" ]]; then + echo "VERSION_CODENAME is not set" >&2 + exit 1 +fi + +if [[ "$ID" == "ubuntu" ]]; then + repository_name="apt-proxy" + components="main universe restricted multiverse" +else + repository_name="debian-proxy" + components="main contrib non-free non-free-firmware" +fi + +install -d /etc/apt/sources.list.d +rm -f /etc/apt/sources.list /etc/apt/sources.list.d/* +printf 'deb [trusted=yes] %s/%s %s %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >/etc/apt/sources.list +printf 'deb [trusted=yes] %s/%s %s-updates %s\n' \ + "$repository_base" "$repository_name" "$codename" "$components" \ + >>/etc/apt/sources.list + +if [[ "$ID" != "ubuntu" ]]; then + printf 'deb [trusted=yes] %s/%s %s-security %s\n' \ + "$repository_base" "debian-proxy-security" "$codename" "$components" \ + >>/etc/apt/sources.list +fi diff --git a/lbcb-sci--racon.a2cfcac/tests/harbor_prepare_download_env.sh b/lbcb-sci--racon.a2cfcac/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lbcb-sci--racon.a2cfcac/tests/programgym_evaluator.py b/lbcb-sci--racon.a2cfcac/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/lbcb-sci--racon.a2cfcac/tests/programgym_task.json b/lbcb-sci--racon.a2cfcac/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..27f24f37d78035be0b09b47749727ffa3c1e5658 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/programgym_task.json @@ -0,0 +1,855 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_getopt_forms.TestLongEqualsForms.test_equals_dash_value_mismatch", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_getopt_forms.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_help_flags_short_circuit_without_consuming_next_token[--help]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_help_flags_short_circuit_without_consuming_next_token[-h]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_no_argument_flags_do_not_consume_next_token[--fragment-correction]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_no_argument_flags_do_not_consume_next_token[--include-unpolished]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_no_argument_flags_do_not_consume_next_token[--no-trimming]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_no_argument_flags_do_not_consume_next_token[-f]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_no_argument_flags_do_not_consume_next_token[-u]", + "eval.tests.test_argument_errors.TestBooleanFlagParsing.test_short_T_is_not_a_valid_short_option", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_fewer_than_three_inputs_errors[positions0]", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_fewer_than_three_inputs_errors[positions1]", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_fewer_than_three_inputs_errors[positions2]", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_invalid_option_does_not_print_help", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_missing_input_goes_to_stderr_only[positions0]", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_missing_input_goes_to_stderr_only[positions1]", + "eval.tests.test_argument_errors.TestMissingInputFiles.test_missing_input_goes_to_stderr_only[positions2]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--error-threshold]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--gap]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--match]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--mismatch]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--quality-threshold]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--threads]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[--window-length]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-e]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-g]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-m]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-q]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-t]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-w]", + "eval.tests.test_argument_errors.TestMissingOptionArguments.test_required_argument_options_need_a_value[-x]", + "eval.tests.test_argument_errors.TestUnknownOptions.test_unknown_flags_rejected[--bogus-unrecognized option '--bogus']", + "eval.tests.test_argument_errors.TestUnknownOptions.test_unknown_flags_rejected[-J-invalid option -- 'J']", + "eval.tests.test_argument_errors.TestUnknownOptions.test_unknown_flags_rejected[-Z9-invalid option -- 'Z']", + "eval.tests.test_argument_errors.TestUnknownOptions.test_unknown_flags_rejected[-z-invalid option -- 'z']", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_default_polish_payload_matches_golden", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_default_polish_stderr_has_full_progress", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_double_dash_end_of_options_separator", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_duplicate_boolean_flags_accepted", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_duplicate_window_reassignment_last_wins", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--error-threshold-0.8]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--gap--6]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--match-7]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--mismatch--8]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--quality-threshold-5.0]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--threads-3]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_each_long_option_assigns_value_and_completes[--window-length-100]", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_equal_sign_single_arg_option", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_excess_positionals_ignored", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_fully_interleaved_options_and_positionals", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_include_unpolished_long_flag_default_payload", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_large_thread_count_completes", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_numeric_option_each_alters_parse_but_still_completes", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_option_after_positional_complete_run", + "eval.tests.test_complete_polish.TestCompleteContigPolish.test_window_too_small_emits_no_consensus", + "eval.tests.test_complete_polish.TestEmptyInputSets.test_empty_sequences_set_fails_cleanly", + "eval.tests.test_complete_polish.TestEmptyInputSets.test_empty_sequences_set_reports_target_loaded_first", + "eval.tests.test_complete_polish.TestEmptyInputSets.test_empty_target_set_fails_cleanly", + "eval.tests.test_complete_polish.TestEmptyInputSets.test_empty_target_set_gzip_variant", + "eval.tests.test_complete_polish.TestEmptyOverlapSet.test_empty_overlaps_fails_cleanly_with_diagnostic", + "eval.tests.test_complete_polish.TestEmptyOverlapSet.test_empty_overlaps_gzip_variant", + "eval.tests.test_complete_polish.TestFragmentCorrection.test_fragment_header_differs_from_contig", + "eval.tests.test_complete_polish.TestFragmentCorrection.test_fragment_with_scoring_options_completes", + "eval.tests.test_complete_polish.TestFragmentCorrection.test_long_fragment_correction_identical", + "eval.tests.test_complete_polish.TestIncludeUnpolished.test_default_drops_uncovered_target", + "eval.tests.test_complete_polish.TestIncludeUnpolished.test_long_include_unpolished_equivalent", + "eval.tests.test_complete_polish.TestIncludeUnpolished.test_u_include_unpolished_emits_uncovered_target", + "eval.tests.test_complete_polish.TestIncludeUnpolished.test_u_with_single_target_still_polishes", + "eval.tests.test_complete_polish.TestInputContentRouting.test_clean_polish_reports_total_timing_on_stderr", + "eval.tests.test_complete_polish.TestInputContentRouting.test_fastq_sequences_input_gzip_variant", + "eval.tests.test_complete_polish.TestInputContentRouting.test_fastq_sequences_input_yields_identical_consensus", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_gzip_and_plain_storage_both_complete[seqs.fa-ovl.paf-target.fa]", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_gzip_and_plain_storage_both_complete[seqs.fa.gz-ovl.paf.gz-target.fa.gz]", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_paf_and_sam_overlap_routes_complete[ovl.paf.gz]", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_paf_and_sam_overlap_routes_complete[ovl.paf]", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_paf_and_sam_overlap_routes_complete[ovl.sam.gz]", + "eval.tests.test_complete_polish.TestInputStorageFormats.test_paf_and_sam_overlap_routes_complete[ovl.sam]", + "eval.tests.test_complete_polish.TestMultiTargetOutput.test_second_record_precedes_first_on_stdout", + "eval.tests.test_complete_polish.TestMultiTargetOutput.test_two_covered_targets_emitted_in_order", + "eval.tests.test_complete_polish.TestNoTrimming.test_all_boolean_flags_combo_complete", + "eval.tests.test_complete_polish.TestNoTrimming.test_no_trimming_completes_cleanly", + "eval.tests.test_complete_polish.TestNoTrimming.test_no_trimming_with_include_unpolished", + "eval.tests.test_complete_polish.TestOutputChannelSeparation.test_all_progress_markers_listed_on_stderr", + "eval.tests.test_complete_polish.TestOutputChannelSeparation.test_polished_consensus_only_on_stdout", + "eval.tests.test_complete_polish.TestOutputChannelSeparation.test_window_too_small_progress_still_reported", + "eval.tests.test_complete_polish.TestOverlapFormatMHAP.test_mhap_gzip_and_plain_variant_both_load", + "eval.tests.test_complete_polish.TestOverlapFormatMHAP.test_mhap_overlap_extension_accepted", + "eval.tests.test_dispatch_polish.TestContigPolishDispatch.test_basic_contig_dispatch_loads_all_inputs", + "eval.tests.test_dispatch_polish.TestContigPolishDispatch.test_default_contig_does_not_emit_fragment_marker", + "eval.tests.test_dispatch_polish.TestContigPolishDispatch.test_long_and_short_boolean_flags_combo", + "eval.tests.test_dispatch_polish.TestContigPolishDispatch.test_options_after_positionals_are_permuted", + "eval.tests.test_dispatch_polish.TestContigPolishDispatch.test_options_before_positionals", + "eval.tests.test_dispatch_polish.TestFragmentCorrectionDispatch.test_fragment_flag_accepted[--fragment-correction]", + "eval.tests.test_dispatch_polish.TestFragmentCorrectionDispatch.test_fragment_flag_accepted[-f]", + "eval.tests.test_dispatch_polish.TestFragmentCorrectionDispatch.test_fragment_flag_with_include_unpolished", + "eval.tests.test_dispatch_polish.TestScoringAndThresholdOptions.test_all_scoring_flags_parse_and_dispatch", + "eval.tests.test_dispatch_polish.TestScoringAndThresholdOptions.test_equal_sign_long_options", + "eval.tests.test_dispatch_polish.TestScoringAndThresholdOptions.test_mismatch_and_gap_negative_values_accepted", + "eval.tests.test_getopt_forms.TestAttachedShortOptionValues.test_attached_thread_value_completes", + "eval.tests.test_getopt_forms.TestAttachedShortOptionValues.test_attached_window_value_completes_default_payload[--window-length=500]", + "eval.tests.test_getopt_forms.TestAttachedShortOptionValues.test_attached_window_value_completes_default_payload[-w500]", + "eval.tests.test_getopt_forms.TestClusteredShortFlags.test_clustered_two_flags_match_separate_flags", + "eval.tests.test_getopt_forms.TestClusteredShortFlags.test_clustered_u_f_route_fragment", + "eval.tests.test_getopt_forms.TestClusteredShortFlags.test_unknown_char_in_cluster_hits_default_branch", + "eval.tests.test_getopt_forms.TestEndOfOptionsSeparator.test_double_dash_then_real_files_completes", + "eval.tests.test_getopt_forms.TestEndOfOptionsSeparator.test_double_dash_treats_dash_prefixed_tokens_as_files", + "eval.tests.test_getopt_forms.TestHelpShortCircuitInCluster.test_help_short_circuits_after_boolean_in_cluster", + "eval.tests.test_getopt_forms.TestLongEqualsForms.test_equals_dash_value_mismatch", + "eval.tests.test_getopt_forms.TestLongEqualsForms.test_equals_empty_value_invalid_window", + "eval.tests.test_getopt_forms.TestLongEqualsForms.test_equals_value_on_gap_is_negative", + "eval.tests.test_input_validation.TestNonexistentFile.test_nonexistent_valid_file_aborts_on_parse[.fa]", + "eval.tests.test_input_validation.TestNonexistentFile.test_nonexistent_valid_file_aborts_on_parse[.fasta.gz]", + "eval.tests.test_input_validation.TestNonexistentFile.test_nonexistent_valid_file_aborts_on_parse[.fastq.gz]", + "eval.tests.test_input_validation.TestNonexistentFile.test_nonexistent_valid_file_aborts_on_parse[.fq]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_bad_overlaps_extension_rejected[.PAF]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_bad_overlaps_extension_rejected[.bam]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_bad_overlaps_extension_rejected[.paf ]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_bad_overlaps_extension_rejected[.sam2]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_bad_overlaps_extension_rejected[.txt]", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_paf_overlaps_accepted", + "eval.tests.test_input_validation.TestOverlapsExtensionValidation.test_sam_overlaps_accepted", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.TXT]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.bam]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.fa ]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.faq]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.taf]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_bad_sequences_extension_rejected[.txt]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_valid_sequences_extension_is_accepted[.fa]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_valid_sequences_extension_is_accepted[.fasta]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_valid_sequences_extension_is_accepted[.fastq]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_valid_sequences_extension_is_accepted[.fna]", + "eval.tests.test_input_validation.TestSequencesExtensionValidation.test_valid_sequences_extension_is_accepted[.fq]", + "eval.tests.test_input_validation.TestTargetExtensionValidation.test_bad_target_extension_rejected[.=]", + "eval.tests.test_input_validation.TestTargetExtensionValidation.test_bad_target_extension_rejected[.dat]", + "eval.tests.test_input_validation.TestTargetExtensionValidation.test_bad_target_extension_rejected[.fa.gz ]", + "eval.tests.test_input_validation.TestTargetExtensionValidation.test_bad_target_extension_rejected[.junk]", + "eval.tests.test_input_validation.TestWindowLengthValidation.test_nonpositive_or_non_numeric_window_length_rejected[0]", + "eval.tests.test_input_validation.TestWindowLengthValidation.test_nonpositive_or_non_numeric_window_length_rejected[0x10]", + "eval.tests.test_input_validation.TestWindowLengthValidation.test_nonpositive_or_non_numeric_window_length_rejected[]", + "eval.tests.test_input_validation.TestWindowLengthValidation.test_nonpositive_or_non_numeric_window_length_rejected[abc]", + "eval.tests.test_input_validation.TestWindowLengthValidation.test_positive_window_length_accepted", + "eval.tests.test_version_help.TestHelpReporting.test_help_documents_numeric_option_defaults", + "eval.tests.test_version_help.TestHelpReporting.test_help_lists_option_defaults", + "eval.tests.test_version_help.TestHelpReporting.test_help_lists_option_names", + "eval.tests.test_version_help.TestHelpReporting.test_help_lists_positional_inputs", + "eval.tests.test_version_help.TestHelpReporting.test_help_never_prints_error_marker", + "eval.tests.test_version_help.TestHelpReporting.test_long_help_prints_usage", + "eval.tests.test_version_help.TestHelpReporting.test_short_and_long_help_identical", + "eval.tests.test_version_help.TestHelpReporting.test_short_h_prints_usage", + "eval.tests.test_version_help.TestVersionReporting.test_long_version_exact", + "eval.tests.test_version_help.TestVersionReporting.test_long_version_shapes_like_semver", + "eval.tests.test_version_help.TestVersionReporting.test_short_dash_v_is_not_a_version_flag", + "eval.tests.test_version_help.TestVersionReporting.test_version_goes_to_stdout_not_stderr", + "eval.tests.test_version_help.TestVersionReporting.test_version_with_extra_positional_ignored" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_cli.test_extra_arguments_beyond_three_are_ignored_for_polish", + "eval.tests.test_cli.test_long_cuda_option_unrecognized_in_cpu_build", + "eval.tests.test_cli.test_long_help_prints_usage_to_stdout", + "eval.tests.test_cli.test_long_version_prints_semver_to_stdout", + "eval.tests.test_cli.test_no_arguments_reports_missing_inputs", + "eval.tests.test_cli.test_short_cuda_option_unrecognized_in_cpu_build", + "eval.tests.test_cli.test_short_help_prints_usage", + "eval.tests.test_cli.test_short_version_flag_is_rejected", + "eval.tests.test_cli.test_two_inputs_only_reports_missing_inputs", + "eval.tests.test_cli.test_unknown_long_option_rejected", + "eval.tests.test_cli.test_unknown_short_option_rejected", + "eval.tests.test_consensus.test_alternate_scoring_matrix_runs", + "eval.tests.test_consensus.test_basic_consensus_matches_target", + "eval.tests.test_consensus.test_consensus_corrects_mutated_reads_to_reference", + "eval.tests.test_consensus.test_consensus_majority_recovers_clean_reference", + "eval.tests.test_consensus.test_fastq_high_quality_bases", + "eval.tests.test_consensus.test_fastq_low_quality_bases", + "eval.tests.test_consensus.test_fna_target_extension", + "eval.tests.test_consensus.test_four_threads_produce_standard_consensus", + "eval.tests.test_consensus.test_fragment_correction_emits_read_tagged_records", + "eval.tests.test_consensus.test_fragment_correction_kind_differs_from_polish", + "eval.tests.test_consensus.test_gzipped_all_inputs", + "eval.tests.test_consensus.test_gzipped_overlaps_only", + "eval.tests.test_consensus.test_huge_window_drops_all_windows_without_include_flag", + "eval.tests.test_consensus.test_huge_window_with_include_emits_unpolished_xc_zero", + "eval.tests.test_consensus.test_lntag_equals_output_sequence_length", + "eval.tests.test_consensus.test_mixed_strand_consensus_pins_golden", + "eval.tests.test_consensus.test_multicontig_target_order_is_preserved", + "eval.tests.test_consensus.test_multithreaded_output_matches_single_thread", + "eval.tests.test_consensus.test_no_trimming_disables_window_trim", + "eval.tests.test_consensus.test_quality_threshold_scan_accepted", + "eval.tests.test_consensus.test_rctag_is_target_coverage", + "eval.tests.test_consensus.test_reverse_strand_overlap_produces_rc_consensus", + "eval.tests.test_consensus.test_run_is_deterministic_across_repeats", + "eval.tests.test_consensus.test_stderr_reports_polisher_lifecycle_stages", + "eval.tests.test_consensus.test_stdout_is_fasta_only_with_tags", + "eval.tests.test_consensus.test_uncovered_target_carries_zero_coverage_and_is_dropped_by_default", + "eval.tests.test_consensus.test_window_length_30_multi_window", + "eval.tests.test_consensus.test_window_length_larger_than_target", + "eval.tests.test_coverage_core.test_fastq_target_and_fastq_reads_both_quality", + "eval.tests.test_coverage_core.test_fastq_target_extension_polishes[fastq]", + "eval.tests.test_coverage_core.test_fastq_target_extension_polishes[fq]", + "eval.tests.test_coverage_core.test_fastq_target_header_uses_target_name", + "eval.tests.test_coverage_core.test_gzip_fastq_target_extension_polishes[fastq.gz]", + "eval.tests.test_coverage_core.test_gzip_fastq_target_extension_polishes[fq.gz]", + "eval.tests.test_coverage_core.test_leading_invalid_overlap_is_compacted", + "eval.tests.test_coverage_core.test_leading_invalid_overlap_matches_golden", + "eval.tests.test_coverage_core.test_mhap_overlaps_format_polishes", + "eval.tests.test_coverage_core.test_mhap_overlaps_gzip_format_polishes", + "eval.tests.test_coverage_core.test_mhap_reverse_strand_overlap_is_deterministic", + "eval.tests.test_coverage_core.test_middle_invalid_overlap_is_compacted", + "eval.tests.test_coverage_core.test_short_gzipped_filenames_accepted", + "eval.tests.test_coverage_core.test_short_sequence_and_target_filenames_accepted", + "eval.tests.test_coverage_core.test_shortname_matches_golden", + "eval.tests.test_factory_validation.test_error_threshold_valid_range_accepted", + "eval.tests.test_factory_validation.test_missing_overlaps_file_aborts_with_open_error", + "eval.tests.test_factory_validation.test_missing_sequences_file_aborts_with_open_error", + "eval.tests.test_factory_validation.test_missing_targets_file_aborts_with_open_error", + "eval.tests.test_factory_validation.test_non_numeric_window_length_treated_as_zero", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[dat]", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[mhap.txt]", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[p]", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[paf.extra]", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[sam.1]", + "eval.tests.test_factory_validation.test_unsupported_overlaps_extension_rejected[txt]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[csv]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[dat]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[fa.gz.extra]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[fa.tag]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[fasa]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[fasta.gz.1]", + "eval.tests.test_factory_validation.test_unsupported_sequences_extension_rejected[txt]", + "eval.tests.test_factory_validation.test_unsupported_target_extension_rejected[bam]", + "eval.tests.test_factory_validation.test_unsupported_target_extension_rejected[dat]", + "eval.tests.test_factory_validation.test_unsupported_target_extension_rejected[fasta.gz.extra]", + "eval.tests.test_factory_validation.test_unsupported_target_extension_rejected[fq.extra]", + "eval.tests.test_factory_validation.test_unsupported_target_extension_rejected[txt]", + "eval.tests.test_factory_validation.test_zero_window_length_rejected", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_3reads-args0]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_fastq_target-args1]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_fastq_target_fastq-args2]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_fastq_target_fastqgz-args3]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_fastq_target_gz-args4]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_highqual-args5]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_include_unpolished-args6]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_leadghost-args7]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_leadghost_mid-args8]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_lowqual-args9]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_mhap-args10]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_mhap_gz-args11]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_mixed-args12]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_notrim-args13]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_permissive-args14]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_reverse-args15]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_scoring-args16]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_shortname-args17]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_tgs-args18]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_threads4-args19]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_tiny-args20]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_w30-args21]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_w3000-args22]", + "eval.tests.test_golden.test_golden_stdout_matches[consensus_w65535_keep-args23]", + "eval.tests.test_golden.test_golden_stdout_matches[drop_default-args24]", + "eval.tests.test_golden.test_golden_stdout_matches[fna_seqext-args25]", + "eval.tests.test_golden.test_golden_stdout_matches[gzip_all-args26]", + "eval.tests.test_golden.test_golden_stdout_matches[keep_uncovered-args27]", + "eval.tests.test_initialize_errors.test_duplicate_sequence_unequal_data_error", + "eval.tests.test_initialize_errors.test_empty_overlaps_error", + "eval.tests.test_initialize_errors.test_empty_reads_error", + "eval.tests.test_initialize_errors.test_empty_target_sequences_error", + "eval.tests.test_initialize_errors.test_error_threshold_accepts_low_error_overlaps", + "eval.tests.test_initialize_errors.test_error_threshold_filters_all_overlaps", + "eval.tests.test_initialize_errors.test_overlaps_all_self_after_filter_error", + "eval.tests.test_is_suffix_guard.test_short_gzip_names_hit_suffix_guard", + "eval.tests.test_is_suffix_guard.test_short_mhap_overlaps_hit_suffix_guard", + "eval.tests.test_is_suffix_guard.test_short_relative_names_hit_suffix_guard", + "eval.tests.test_is_suffix_guard.test_short_run_is_repeatable_and_parallel_safe", + "eval.tests.test_is_suffix_guard.test_short_target_header_uses_sequence_content", + "eval.tests.test_is_suffix_guard.test_varied_short_stems_all_produce_reference[ab.fa-cd.paf-ef.fa]", + "eval.tests.test_is_suffix_guard.test_varied_short_stems_all_produce_reference[foo.fa-bar.paf-baz.fa]", + "eval.tests.test_is_suffix_guard.test_varied_short_stems_all_produce_reference[x.fa-y.paf-z.fa]", + "eval.tests.test_sample_endtoend.test_consensus_sample_fasta_reads_no_quality", + "eval.tests.test_sample_endtoend.test_consensus_sample_fastq_paf", + "eval.tests.test_sample_endtoend.test_consensus_sample_sam_overlap_format" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_overlap_cli.TestArgumentValidation.test_missing_input_files_abort[no-args]", + "eval.tests.test_overlap_cli.TestArgumentValidation.test_missing_input_files_abort[one-file]", + "eval.tests.test_overlap_cli.TestArgumentValidation.test_missing_input_files_abort[two-files]", + "eval.tests.test_overlap_cli.TestArgumentValidation.test_unknown_option_rejected", + "eval.tests.test_overlap_cli.TestEmptySets.test_empty_overlaps_aborts", + "eval.tests.test_overlap_cli.TestEmptySets.test_empty_sequences_aborts", + "eval.tests.test_overlap_cli.TestEmptySets.test_empty_targets_aborts", + "eval.tests.test_overlap_cli.TestHelpAndVersion.test_help_prints_full_usage[long]", + "eval.tests.test_overlap_cli.TestHelpAndVersion.test_help_prints_full_usage[short]", + "eval.tests.test_overlap_cli.TestHelpAndVersion.test_short_v_flag_is_rejected", + "eval.tests.test_overlap_cli.TestHelpAndVersion.test_version_flag_prints_version", + "eval.tests.test_overlap_cli.TestOverlapFormatDispatch.test_unsupported_overlap_extension[data]", + "eval.tests.test_overlap_cli.TestOverlapFormatDispatch.test_unsupported_overlap_extension[noext]", + "eval.tests.test_overlap_cli.TestOverlapFormatDispatch.test_unsupported_overlap_extension[txt]", + "eval.tests.test_overlap_gzip_multiread.TestGzipOverlapInput.test_gzip_and_plain_paf_are_byte_identical", + "eval.tests.test_overlap_gzip_multiread.TestGzipOverlapInput.test_gzip_paf_overlap_polishes", + "eval.tests.test_overlap_gzip_multiread.TestGzipOverlapInput.test_gzip_sam_overlap_polishes", + "eval.tests.test_overlap_gzip_multiread.TestMultiReadConsensus.test_three_reads_single_window_rc3", + "eval.tests.test_overlap_mhap.TestMhapIdLookup.test_lhs_length_mismatch_aborts", + "eval.tests.test_overlap_mhap.TestMhapIdLookup.test_out_of_range_lhs_id_drops_overlap", + "eval.tests.test_overlap_mhap.TestMhapIdLookup.test_out_of_range_rhs_id_drops_overlap", + "eval.tests.test_overlap_mhap.TestMhapIdLookup.test_rhs_length_mismatch_aborts", + "eval.tests.test_overlap_mhap.TestMhapIdLookup.test_valid_id_based_overlap_polishes", + "eval.tests.test_overlap_mhap.TestMhapSelfOverlap.test_self_overlap_rejected", + "eval.tests.test_overlap_mhap.TestMhapStrand.test_strand_xor_polish_matches_golden[rr]", + "eval.tests.test_overlap_mhap.TestMhapStrand.test_strand_xor_polish_matches_golden[rs]", + "eval.tests.test_overlap_mhap.TestMhapStrand.test_strand_xor_polish_matches_golden[sr]", + "eval.tests.test_overlap_mhap.TestMhapStrand.test_strand_xor_polish_matches_golden[ss]", + "eval.tests.test_overlap_paf.TestPafErrorThreshold.test_default_threshold_keeps_low_error_overlap", + "eval.tests.test_overlap_paf.TestPafErrorThreshold.test_threshold_one_keeps_overlap", + "eval.tests.test_overlap_paf.TestPafErrorThreshold.test_threshold_zero_drops_overlap", + "eval.tests.test_overlap_paf.TestPafLengthFilter.test_two_same_query_overlaps_different_lengths", + "eval.tests.test_overlap_paf.TestPafLengthFilter.test_two_same_query_overlaps_equal_length", + "eval.tests.test_overlap_paf.TestPafNameLookup.test_invalid_overlap_keeps_valid_sibling", + "eval.tests.test_overlap_paf.TestPafNameLookup.test_unknown_name_drops_overlap[unknown-both]", + "eval.tests.test_overlap_paf.TestPafNameLookup.test_unknown_name_drops_overlap[unknown-q]", + "eval.tests.test_overlap_paf.TestPafNameLookup.test_unknown_name_drops_overlap[unknown-t]", + "eval.tests.test_overlap_paf.TestPafStrand.test_strand_polish_matches_golden[forward]", + "eval.tests.test_overlap_paf.TestPafStrand.test_strand_polish_matches_golden[reverse]", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_matching_lengths_polish_matches_golden", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_unequal_q_length_aborts[qlen-too-long]", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_unequal_q_length_aborts[qlen-too-short]", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_unequal_q_length_aborts[qlen-zero]", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_unequal_t_length_aborts[tlen-too-long]", + "eval.tests.test_overlap_paf.TestPafTransmuteLengthValidation.test_unequal_t_length_aborts[tlen-too-short]", + "eval.tests.test_overlap_paf.TestPafWindowBreakingPoints.test_multiwindow_output_record", + "eval.tests.test_overlap_paf.TestPafWindowBreakingPoints.test_window_size_polish_matches_golden[w1000]", + "eval.tests.test_overlap_paf.TestPafWindowBreakingPoints.test_window_size_polish_matches_golden[w100]", + "eval.tests.test_overlap_paf.TestPafWindowBreakingPoints.test_window_size_polish_matches_golden[w500]", + "eval.tests.test_overlap_paf.TestPafWindowBreakingPoints.test_window_size_polish_matches_golden[w50]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_cigar_derived_qlen_mismatch_aborts", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[40M]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[hard-10H]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[internal-soft]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[mismatch-X]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[padding-P]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[soft-5S]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_read_friendly_cigar_polishes[with-insertion]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_target_consuming_cigar_polishes[intron-N]", + "eval.tests.test_overlap_sam.TestSamCigarParsing.test_target_consuming_cigar_polishes[with-deletion]", + "eval.tests.test_overlap_sam.TestSamDeletionWindowBoundary.test_deletion_crosses_window_boundary", + "eval.tests.test_overlap_sam.TestSamDeletionWindowBoundary.test_intron_crosses_window_boundary", + "eval.tests.test_overlap_sam.TestSamMissingAlignment.test_empty_cigar_is_rejected", + "eval.tests.test_overlap_sam.TestSamMissingAlignment.test_undersize_cigar_exits[cigar-I]", + "eval.tests.test_overlap_sam.TestSamMissingAlignment.test_undersize_cigar_exits[cigar-M]", + "eval.tests.test_overlap_sam.TestSamMissingAlignment.test_undersize_cigar_exits[cigar-S]", + "eval.tests.test_overlap_sam.TestSamMissingAlignment.test_valid_cigar_polishes_to_golden", + "eval.tests.test_overlap_sam.TestSamStrand.test_reverse_strand_polishes[flag0x10]", + "eval.tests.test_overlap_sam.TestSamStrand.test_reverse_strand_polishes[flag0x30]", + "eval.tests.test_overlap_sam.TestSamStrand.test_reverse_strand_polishes[flag0x50]", + "eval.tests.test_overlap_sam.TestSamTransmuteName.test_unknown_rname_drops_overlap", + "eval.tests.test_overlap_sam.TestSamUnmappedFlag.test_unmapped_flag_drops_overlap[flag0x0c]", + "eval.tests.test_overlap_sam.TestSamUnmappedFlag.test_unmapped_flag_drops_overlap[flag0x14]", + "eval.tests.test_overlap_sam.TestSamUnmappedFlag.test_unmapped_flag_drops_overlap[flag0xc4]", + "eval.tests.test_overlap_sam.TestSamUnmappedFlag.test_unmapped_flag_drops_overlap[flag4]" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_add_layer.test_common_insertion_survives_into_consensus", + "eval.tests.test_add_layer.test_high_coverage_layer_set", + "eval.tests.test_add_layer.test_include_unpolished_changes_delivery", + "eval.tests.test_add_layer.test_majority_deletion_removed_from_consensus", + "eval.tests.test_add_layer.test_mixed_orientation_layers_accumulate", + "eval.tests.test_add_layer.test_partial_overlap_uses_subgraph_path", + "eval.tests.test_add_layer.test_quality_bearing_reads_provide_layer_quality", + "eval.tests.test_add_layer.test_reverse_strand_layers_form_consensus", + "eval.tests.test_add_layer.test_reverse_strand_with_quality_reads", + "eval.tests.test_add_layer.test_target_exactly_window_length_single_window", + "eval.tests.test_add_layer.test_varied_quality_profiles_per_layer", + "eval.tests.test_cli_reachability.test_executable_empty_extension_overlaps_rejected", + "eval.tests.test_cli_reachability.test_help_flag_prints_documented_option_surface", + "eval.tests.test_cli_reachability.test_help_flag_stderr_is_clean", + "eval.tests.test_cli_reachability.test_missing_input_files_rejected[args0-no-args]", + "eval.tests.test_cli_reachability.test_missing_input_files_rejected[args1-one-input]", + "eval.tests.test_cli_reachability.test_missing_input_files_rejected[args2-two-inputs]", + "eval.tests.test_cli_reachability.test_short_help_flag_lists_window_length_knob", + "eval.tests.test_cli_reachability.test_unknown_short_option_rejected", + "eval.tests.test_cli_reachability.test_unsupported_sequence_extension_rejected", + "eval.tests.test_cli_reachability.test_valid_three_file_invocation_runs", + "eval.tests.test_cli_reachability.test_version_flag_reports_version", + "eval.tests.test_cli_reachability.test_version_flag_writes_nothing_to_stderr", + "eval.tests.test_consensus_paths.test_consensus_threshold_on_sequence_count[1-0.000000]", + "eval.tests.test_consensus_paths.test_consensus_threshold_on_sequence_count[2-1.000000]", + "eval.tests.test_consensus_paths.test_consensus_threshold_on_sequence_count[3-1.000000]", + "eval.tests.test_consensus_paths.test_consensus_threshold_on_sequence_count[4-1.000000]", + "eval.tests.test_consensus_paths.test_empty_sequences_file_is_rejected", + "eval.tests.test_consensus_paths.test_full_coverage_produces_consensus", + "eval.tests.test_consensus_paths.test_include_unpolished_flag_keeps_low_coverage_window", + "eval.tests.test_consensus_paths.test_low_coverage_window_emits_backbone_sequence", + "eval.tests.test_consensus_paths.test_rc_tag_counts_overlaps_per_target", + "eval.tests.test_consensus_paths.test_single_read_window_dropped_without_include_flag", + "eval.tests.test_consensus_paths.test_single_read_window_included_surfaces_two_sequence_state", + "eval.tests.test_create_window.test_fasta_reads_no_quality_null_layer", + "eval.tests.test_create_window.test_fastq_reads_accepted_for_layer_quality", + "eval.tests.test_create_window.test_gzip_compressed_inputs_create_window", + "eval.tests.test_create_window.test_multiple_targets_each_get_windows", + "eval.tests.test_create_window.test_window_created_from_fasta_target", + "eval.tests.test_create_window.test_window_created_from_fastq_target", + "eval.tests.test_create_window.test_window_length_changes_total_consensus_length[100-250]", + "eval.tests.test_create_window.test_window_length_changes_total_consensus_length[500-1000]", + "eval.tests.test_create_window.test_window_length_single_fits_all", + "eval.tests.test_create_window.test_window_length_splits_target_polished_fraction[100-0.533333]", + "eval.tests.test_create_window.test_window_length_splits_target_polished_fraction[1000-1.000000]", + "eval.tests.test_create_window.test_window_length_splits_target_polished_fraction[250-0.500000]", + "eval.tests.test_create_window.test_window_length_splits_target_polished_fraction[500-0.666667]", + "eval.tests.test_create_window.test_wrapped_multiline_target_creates_window", + "eval.tests.test_create_window.test_zero_window_length_rejected", + "eval.tests.test_input_formats.test_fastq_target_with_fastq_reads_combines_real_quality", + "eval.tests.test_input_formats.test_fragment_correction_mode_appends_name_tag", + "eval.tests.test_input_formats.test_gzip_compressed_paf_overlaps_create_windows", + "eval.tests.test_input_formats.test_multi_target_varied_lengths_each_get_windows", + "eval.tests.test_input_formats.test_trailing_stretch_reads_use_subgraph_alignment", + "eval.tests.test_trimming.test_kngs_trimming_is_noop", + "eval.tests.test_trimming.test_short_reads_never_trimmed_by_read_length[400]", + "eval.tests.test_trimming.test_short_reads_never_trimmed_by_read_length[999]", + "eval.tests.test_trimming.test_tgs_no_trimming_keeps_full_length", + "eval.tests.test_trimming.test_tgs_trimming_reduces_consensus_length", + "eval.tests.test_trimming.test_trimming_flag_changes_output", + "eval.tests.test_window_dynamics.test_fully_covered_target_above_window_reassembles_full_length[1000]", + "eval.tests.test_window_dynamics.test_fully_covered_target_above_window_reassembles_full_length[1100]", + "eval.tests.test_window_dynamics.test_fully_covered_target_above_window_reassembles_full_length[1200]", + "eval.tests.test_window_dynamics.test_fully_covered_target_above_window_reassembles_full_length[450]", + "eval.tests.test_window_dynamics.test_fully_covered_target_above_window_reassembles_full_length[900]", + "eval.tests.test_window_dynamics.test_fully_covered_target_slices_at_multiple_window_lengths[1200]", + "eval.tests.test_window_dynamics.test_fully_covered_target_slices_at_multiple_window_lengths[250]", + "eval.tests.test_window_dynamics.test_fully_covered_target_slices_at_multiple_window_lengths[400]", + "eval.tests.test_window_dynamics.test_fully_covered_target_slices_at_multiple_window_lengths[600]", + "eval.tests.test_window_dynamics.test_fully_covered_target_slices_at_multiple_window_lengths[800]", + "eval.tests.test_window_dynamics.test_multithreaded_consensus_over_multi_window_target", + "eval.tests.test_window_dynamics.test_tgs_full_coverage_trim_is_noop", + "eval.tests.test_window_dynamics.test_tgs_interior_forward_strand_trims_both_ends", + "eval.tests.test_window_dynamics.test_tgs_interior_reverse_strand_trims_both_ends", + "eval.tests.test_window_dynamics.test_tgs_left_stretch_reads_trim_only_right_end" + ] + }, + "generated_module_05": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_sequence_ambiguous_bases.test_reverse_u_base_captured_oracle", + "reasons": [ + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_sequence_ambiguous_bases.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_sequence_ambiguous_bases.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_sequence_multi_target_ordering.test_three_targets_mixed_strands_record_order", + "reasons": [ + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_sequence_multi_target_ordering.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_sequence_ambiguous_bases.test_ambiguous_reverse_deterministic_across_threads", + "eval.tests.test_sequence_ambiguous_bases.test_forward_x_base_uppercased_and_kept", + "eval.tests.test_sequence_ambiguous_bases.test_lowercase_ambiguous_input_reverse_exact", + "eval.tests.test_sequence_ambiguous_bases.test_lowercase_ambiguous_input_uppercased_forward", + "eval.tests.test_sequence_ambiguous_bases.test_reverse_u_base_captured_oracle", + "eval.tests.test_sequence_ambiguous_bases.test_reverse_x_base_passthrough_exact", + "eval.tests.test_sequence_ambiguous_bases.test_reverse_x_positional_not_complemented", + "eval.tests.test_sequence_behavior.test_consensus_adopts_read_substitutions_forward[substitutions0-AACCCGTTACGTGAATTCGCGTAAACCGGTT]", + "eval.tests.test_sequence_behavior.test_consensus_adopts_read_substitutions_forward[substitutions1-AACCGGTTTCGTGAATTCGCGTAAACCGGTT]", + "eval.tests.test_sequence_behavior.test_consensus_adopts_read_substitutions_forward[substitutions2-AACCGGTTACGTGAAATCGCGTAACCCGGTT]", + "eval.tests.test_sequence_behavior.test_consensus_adopts_read_substitutions_forward[substitutions3-AACCCGTTACGTGAATTCCCGTAAACCGGTT]", + "eval.tests.test_sequence_behavior.test_consensus_adopts_read_substitutions_reverse", + "eval.tests.test_sequence_behavior.test_duplicate_sequence_with_unequal_data_aborts", + "eval.tests.test_sequence_behavior.test_read_identical_to_target_merged_rc_excludes_self", + "eval.tests.test_sequence_behavior.test_read_overlapping_target_on_both_strands_stays_forward", + "eval.tests.test_sequence_behavior.test_reverse_majority_with_corrected_reads_uses_reverse_quality", + "eval.tests.test_sequence_errors.test_empty_overlap_set", + "eval.tests.test_sequence_errors.test_empty_sequences_set", + "eval.tests.test_sequence_errors.test_empty_target_set", + "eval.tests.test_sequence_errors.test_help_flag", + "eval.tests.test_sequence_errors.test_long_help_flag", + "eval.tests.test_sequence_errors.test_missing_all_inputs", + "eval.tests.test_sequence_errors.test_non_numeric_window_length", + "eval.tests.test_sequence_errors.test_nonexistent_sequences_file_aborts", + "eval.tests.test_sequence_errors.test_one_input_file", + "eval.tests.test_sequence_errors.test_too_few_inputs_two_files", + "eval.tests.test_sequence_errors.test_unknown_option_rejected", + "eval.tests.test_sequence_errors.test_unsupported_overlaps_extension", + "eval.tests.test_sequence_errors.test_unsupported_overlaps_in_sam_extension_list", + "eval.tests.test_sequence_errors.test_unsupported_sequences_extension", + "eval.tests.test_sequence_errors.test_unsupported_target_extension", + "eval.tests.test_sequence_errors.test_valid_priority_of_ext_check_before_read", + "eval.tests.test_sequence_errors.test_version_flag", + "eval.tests.test_sequence_errors.test_zero_window_length", + "eval.tests.test_sequence_golden_output.test_golden_forward_polished_stdout", + "eval.tests.test_sequence_golden_output.test_golden_stdout_is_exact_single_record", + "eval.tests.test_sequence_input_formats.test_error_threshold_does_not_degrade_identical_reads[0.0]", + "eval.tests.test_sequence_input_formats.test_error_threshold_does_not_degrade_identical_reads[0.1]", + "eval.tests.test_sequence_input_formats.test_error_threshold_does_not_degrade_identical_reads[0.3]", + "eval.tests.test_sequence_input_formats.test_error_threshold_does_not_degrade_identical_reads[0.9]", + "eval.tests.test_sequence_input_formats.test_error_threshold_does_not_degrade_identical_reads[1.0]", + "eval.tests.test_sequence_input_formats.test_fastq_extensions_produce_identical_output[reads.fastq-target.fastq-fastq]", + "eval.tests.test_sequence_input_formats.test_fastq_extensions_produce_identical_output[reads.fq-target.fq-fastq]", + "eval.tests.test_sequence_input_formats.test_fragment_mode_self_overlaps_required", + "eval.tests.test_sequence_input_formats.test_fragment_mode_successful_polish", + "eval.tests.test_sequence_input_formats.test_input_extensions_produce_identical_output[reads.fa-target.fa-ovl.paf]", + "eval.tests.test_sequence_input_formats.test_input_extensions_produce_identical_output[reads.fasta-target.fasta-ovl.paf]", + "eval.tests.test_sequence_input_formats.test_input_extensions_produce_identical_output[reads.fasta.gz-target.fasta.gz-ovl.paf.gz]", + "eval.tests.test_sequence_input_formats.test_input_extensions_produce_identical_output[reads.fna-target.fna-ovl.paf]", + "eval.tests.test_sequence_input_formats.test_input_extensions_produce_identical_output[reads.fna.gz-target.fna.gz-ovl.paf]", + "eval.tests.test_sequence_input_formats.test_target_as_fastq_all_bang_quality_ignored", + "eval.tests.test_sequence_input_formats.test_target_as_fastq_with_real_quality", + "eval.tests.test_sequence_integration.test_consensus_with_qualities", + "eval.tests.test_sequence_integration.test_consensus_with_qualities_and_alignments", + "eval.tests.test_sequence_multi_target_ordering.test_multi_target_ordered_deterministic_across_threads", + "eval.tests.test_sequence_multi_target_ordering.test_orphan_target_dropped_by_default_multitarget", + "eval.tests.test_sequence_multi_target_ordering.test_orphan_target_kept_with_include_multitarget", + "eval.tests.test_sequence_multi_target_ordering.test_three_targets_header_tags_are_per_target", + "eval.tests.test_sequence_multi_target_ordering.test_three_targets_mixed_strands_record_order", + "eval.tests.test_sequence_new_branches.test_covered_but_unpolished_target_dropped_by_default", + "eval.tests.test_sequence_new_branches.test_covered_but_unpolished_target_kept_with_include", + "eval.tests.test_sequence_new_branches.test_duplicate_read_names_collapse_coverage[2]", + "eval.tests.test_sequence_new_branches.test_duplicate_read_names_collapse_coverage[3]", + "eval.tests.test_sequence_new_branches.test_partial_forward_overlap_keeps_full_target", + "eval.tests.test_sequence_new_branches.test_partial_overlaps_deterministic_across_threads", + "eval.tests.test_sequence_new_branches.test_partial_reverse_overlap_exact_oracle", + "eval.tests.test_sequence_new_branches.test_unshared_read_without_overlap_dropped", + "eval.tests.test_sequence_output_tags.test_long_target_over_window_single_sequence", + "eval.tests.test_sequence_output_tags.test_no_trimming_keeps_full_polished_length", + "eval.tests.test_sequence_output_tags.test_orphan_target_dropped_by_default", + "eval.tests.test_sequence_output_tags.test_orphan_target_kept_with_include_unpolished", + "eval.tests.test_sequence_output_tags.test_polished_header_tags", + "eval.tests.test_sequence_output_tags.test_single_read_unpolished_ratio_zero", + "eval.tests.test_sequence_output_tags.test_two_reads_polished_ratio_one", + "eval.tests.test_sequence_output_tags.test_two_targets_both_in_output", + "eval.tests.test_sequence_parametrized.test_forward_orientation_output_matches_reads[2]", + "eval.tests.test_sequence_parametrized.test_forward_orientation_output_matches_reads[3]", + "eval.tests.test_sequence_parametrized.test_forward_orientation_output_matches_reads[4]", + "eval.tests.test_sequence_parametrized.test_quality_threshold_boundary_forward[0-1.000000]", + "eval.tests.test_sequence_parametrized.test_quality_threshold_boundary_forward[100-0.000000]", + "eval.tests.test_sequence_parametrized.test_quality_threshold_boundary_forward[40-1.000000]", + "eval.tests.test_sequence_parametrized.test_quality_threshold_boundary_forward[41-0.000000]", + "eval.tests.test_sequence_parametrized.test_quality_threshold_boundary_forward[5-1.000000]", + "eval.tests.test_sequence_parametrized.test_rc_coverage_equals_num_reads[1]", + "eval.tests.test_sequence_parametrized.test_rc_coverage_equals_num_reads[2]", + "eval.tests.test_sequence_parametrized.test_rc_coverage_equals_num_reads[3]", + "eval.tests.test_sequence_parametrized.test_rc_coverage_equals_num_reads[4]", + "eval.tests.test_sequence_parametrized.test_rc_coverage_equals_num_reads[5]", + "eval.tests.test_sequence_parametrized.test_repeated_run_determinism", + "eval.tests.test_sequence_parametrized.test_reverse_orientation_output_is_golden_rc[2]", + "eval.tests.test_sequence_parametrized.test_reverse_orientation_output_is_golden_rc[3]", + "eval.tests.test_sequence_parametrized.test_reverse_orientation_output_is_golden_rc[4]", + "eval.tests.test_sequence_parametrized.test_thread_count_determinism[1]", + "eval.tests.test_sequence_parametrized.test_thread_count_determinism[2]", + "eval.tests.test_sequence_parametrized.test_thread_count_determinism[4]", + "eval.tests.test_sequence_parametrized.test_window_splitting_output_consistency", + "eval.tests.test_sequence_parametrized.test_window_splitting_polished_ratio[10-0.750000]", + "eval.tests.test_sequence_parametrized.test_window_splitting_polished_ratio[100-1.000000]", + "eval.tests.test_sequence_parametrized.test_window_splitting_polished_ratio[15-0.666667]", + "eval.tests.test_sequence_parametrized.test_window_splitting_polished_ratio[31-1.000000]", + "eval.tests.test_sequence_parametrized.test_window_splitting_polished_ratio[50-1.000000]", + "eval.tests.test_sequence_quality.test_all_bang_quality_ignores_threshold", + "eval.tests.test_sequence_quality.test_fasta_no_quality_ignores_threshold", + "eval.tests.test_sequence_quality.test_high_quality_reads_polish_under_low_threshold", + "eval.tests.test_sequence_quality.test_low_quality_reads_skipped_under_high_threshold", + "eval.tests.test_sequence_quality.test_low_quality_reverse_strand_skipped", + "eval.tests.test_sequence_quality.test_quality_threshold_rc_coverage_independent", + "eval.tests.test_sequence_reverse_complement.test_forward_output", + "eval.tests.test_sequence_reverse_complement.test_mixed_strand_majority_forward", + "eval.tests.test_sequence_reverse_complement.test_mixed_strand_majority_reverse", + "eval.tests.test_sequence_reverse_complement.test_reverse_complement_equals_theoretical", + "eval.tests.test_sequence_reverse_complement.test_reverse_complement_lowercase_input_yields_uppercase_rc", + "eval.tests.test_sequence_reverse_complement.test_reverse_complement_output", + "eval.tests.test_sequence_reverse_complement.test_reverse_complement_single_reverse_read_unpolished", + "eval.tests.test_sequence_reverse_complement.test_reverse_consensus_golden_distinct_sequence[T2]", + "eval.tests.test_sequence_reverse_complement.test_reverse_consensus_golden_distinct_sequence[T3]", + "eval.tests.test_sequence_reverse_complement.test_reverse_consensus_golden_distinct_sequence[T6]", + "eval.tests.test_sequence_reverse_complement.test_reverse_consensus_n_bases_thrown_through", + "eval.tests.test_sequence_reverse_complement.test_two_targets_independent_strands", + "eval.tests.test_sequence_uppercase.test_lowercase_fastq_reads_uppercased", + "eval.tests.test_sequence_uppercase.test_lowercase_reads_and_target_uppercased", + "eval.tests.test_sequence_uppercase.test_lowercase_target_only_uppercased_output", + "eval.tests.test_sequence_uppercase.test_mixed_case_input_uppercased" + ] + }, + "generated_module_06": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_logger_consensus.test_include_unpolished_byte_identical_to_plain_default_run", + "reasons": [ + { + "id": "test_network_dependency", + "message": "test appears to depend on networking", + "path": "eval/tests/test_logger_consensus.py", + "repair_hint": "Remove external networking from eval tests; use bundled fixtures or local subprocess behavior.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_logger_cli.test_empty_overlap_set_prints_initialized_logs", + "eval.tests.test_logger_cli.test_help_lists_options_exact_blocks", + "eval.tests.test_logger_cli.test_help_matches_exact_golden", + "eval.tests.test_logger_cli.test_input_reading_order_respected", + "eval.tests.test_logger_cli.test_malformed_target_aborts_bioparser", + "eval.tests.test_logger_cli.test_missing_input_files_reports_error", + "eval.tests.test_logger_cli.test_missing_option_value_reports_option_requires_argument", + "eval.tests.test_logger_cli.test_short_help_flag_identical_to_long_help", + "eval.tests.test_logger_cli.test_too_few_positional_inputs", + "eval.tests.test_logger_cli.test_unknown_option_reports_exact_option", + "eval.tests.test_logger_cli.test_unsupported_overlap_extension", + "eval.tests.test_logger_cli.test_unsupported_sequences_extension", + "eval.tests.test_logger_cli.test_version_flag_exact_string", + "eval.tests.test_logger_consensus.test_consensus_header_carries_exact_output_tags", + "eval.tests.test_logger_consensus.test_consensus_header_length_matches_emitted_sequence", + "eval.tests.test_logger_consensus.test_consensus_sequence_is_valid_dna_alphabet", + "eval.tests.test_logger_consensus.test_default_consensus_exactly_matches_golden", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args0-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args1-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args2-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args3-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args4-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args5-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args6-LN]", + "eval.tests.test_logger_consensus.test_each_parameter_variant_conforms_to_header_schema[args7-LN]", + "eval.tests.test_logger_consensus.test_error_threshold_tight_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_error_threshold_zero_emits_no_consensus_golden", + "eval.tests.test_logger_consensus.test_include_unpolished_byte_identical_to_plain_default_run", + "eval.tests.test_logger_consensus.test_match_score_four_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_match_score_two_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_max_error_threshold_matches_default_consensus", + "eval.tests.test_logger_consensus.test_no_trimming_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_no_trimming_combined_with_window_length_golden", + "eval.tests.test_logger_consensus.test_plain_consensus_log_comes_after_transformed_windows", + "eval.tests.test_logger_consensus.test_quality_threshold_zero_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_scoring_parameters_produce_distinct_consensus", + "eval.tests.test_logger_consensus.test_thread_count_changes_no_consensus_output", + "eval.tests.test_logger_consensus.test_window_length_1000_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_window_length_200_alters_consensus_golden", + "eval.tests.test_logger_consensus.test_window_length_beyond_window_count_emits_plain_consensus_log", + "eval.tests.test_logger_consensus.test_window_quality_error_combination_alters_consensus_golden", + "eval.tests.test_logger_messages.test_aligning_overlaps_bar_full_bracket_sequence", + "eval.tests.test_logger_messages.test_aligning_overlaps_bar_monotonic_growth", + "eval.tests.test_logger_messages.test_aligning_overlaps_each_frame_has_seconds", + "eval.tests.test_logger_messages.test_aligning_overlaps_ends_on_full_bar", + "eval.tests.test_logger_messages.test_aligning_overlaps_frames_carriage_return_joined", + "eval.tests.test_logger_messages.test_aligning_overlaps_only_arrow_in_unfilled", + "eval.tests.test_logger_messages.test_all_log_lines_match_exact_fixedpoint_format", + "eval.tests.test_logger_messages.test_bar_resets_and_emits_final_newline", + "eval.tests.test_logger_messages.test_default_initialize_log_messages_count", + "eval.tests.test_logger_messages.test_generating_consensus_bar_full_sequence", + "eval.tests.test_logger_messages.test_generating_consensus_bar_monotonic", + "eval.tests.test_logger_messages.test_generating_consensus_final_full_bar", + "eval.tests.test_logger_messages.test_loaded_overlaps_suffix_s", + "eval.tests.test_logger_messages.test_loaded_sequences_fixedpoint_six_decimals", + "eval.tests.test_logger_messages.test_loaded_target_sequences_format", + "eval.tests.test_logger_messages.test_loader_log_lines_precede_first_progress_bar", + "eval.tests.test_logger_messages.test_log_messages_written_to_stderr_not_stdout", + "eval.tests.test_logger_messages.test_log_time_nonnegative_on_all_lines", + "eval.tests.test_logger_messages.test_stdout_carries_polished_consensus_fasta", + "eval.tests.test_logger_messages.test_total_after_progress_bars", + "eval.tests.test_logger_messages.test_total_message_fixedpoint_decimal_count", + "eval.tests.test_logger_messages.test_total_message_is_last_logical_line", + "eval.tests.test_logger_messages.test_total_message_present_and_wellformed", + "eval.tests.test_logger_messages.test_transformed_data_into_windows_message", + "eval.tests.test_logger_messages.test_transformed_windows_message_between_bars", + "eval.tests.test_logger_parameters.test_error_threshold_drives_aligned_overlaps_plain_log", + "eval.tests.test_logger_parameters.test_error_threshold_preserves_consensus_bar_with_few_windows", + "eval.tests.test_logger_parameters.test_four_threads_run_logs_consensus", + "eval.tests.test_logger_parameters.test_fragment_correction_alters_consensus", + "eval.tests.test_logger_parameters.test_fragment_correction_mode_runs", + "eval.tests.test_logger_parameters.test_high_quality_filters_all_consensus_output", + "eval.tests.test_logger_parameters.test_include_unpolished_keeps_full_consensus", + "eval.tests.test_logger_parameters.test_lower_error_threshold_alters_consensus", + "eval.tests.test_logger_parameters.test_negative_window_length_aborts_before_logging", + "eval.tests.test_logger_parameters.test_non_numeric_threads_crashes_after_logging", + "eval.tests.test_logger_parameters.test_pipeline_default_success_exit_code", + "eval.tests.test_logger_parameters.test_quality_threshold_controls_window_filtering", + "eval.tests.test_logger_parameters.test_sam_overlap_format_reaches_logger", + "eval.tests.test_logger_parameters.test_single_thread_run_logs_consensus", + "eval.tests.test_logger_parameters.test_two_identical_runs_are_deterministic", + "eval.tests.test_logger_parameters.test_zero_threads_crashes_after_logging" + ] + }, + "generated_upstream": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_racon_initialize_errors.test_overlaps_bad_extension_rejected", + "eval.tests.test_racon_initialize_errors.test_sequences_bad_extension_rejected", + "eval.tests.test_racon_initialize_errors.test_target_bad_extension_rejected", + "eval.tests.test_racon_initialize_errors.test_window_length_zero_rejected", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[edit_distance_scoring]", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[larger_window]", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[with_qualities]", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[with_qualities_and_alignments]", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[without_qualities]", + "eval.tests.test_racon_upstream.test_contig_polish_emits_single_consensus[without_qualities_and_with_alignments]", + "eval.tests.test_racon_upstream.test_fragment_correction_full[full_mhap]", + "eval.tests.test_racon_upstream.test_fragment_correction_full[full_paf_aminofrag]", + "eval.tests.test_racon_upstream.test_fragment_correction_full[full_paf_nucl]", + "eval.tests.test_racon_upstream.test_fragment_correction_with_qualities" + ] + } + }, + "commit": "a2cfcac281d312a73912a97d6d960404f516c389", + "data_source": "synthetic_programgym", + "difficulty": "medium", + "difficulty_score": 2.509336958017644, + "eval_clean_hashes": [ + "fe32411d67dbad24e8f25fac9c2c151a942ed3b20363d786d793fbcb0bb200a0" + ], + "input_record": { + "commit": "a2cfcac281d312a73912a97d6d960404f516c389", + "difficulty": "medium", + "difficulty_code_lines": 3231, + "difficulty_has_tests": true, + "difficulty_product_code_lines": 3231, + "difficulty_runtime_deps": 9, + "difficulty_score": 2.509336958017644, + "difficulty_test_code_lines": 507, + "full_name": "lbcb-sci/racon", + "input_joern_zip": "cpp_joern/lbcb-sci__racon.zip", + "joern_status": true, + "joern_time": 24.17838343884796, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 260, + "similarity": 0.5006417036056519 + } + ], + "repo_path": "cpp/lbcb-sci__racon", + "source": "commit:a2cfcac281d312a73912a97d6d960404f516c389", + "status": "done", + "url": "https://github.com/lbcb-sci/racon" + }, + "instance_id": "lbcb-sci__racon.a2cfcac", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 6, + "branch_name": "generated_module_01", + "iteration_limit": 10, + "module_index": 1, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 3, + "branch_name": "generated_module_02", + "iteration_limit": 10, + "module_index": 2, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 4, + "branch_name": "generated_module_03", + "iteration_limit": 10, + "module_index": 3, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 4, + "branch_name": "generated_module_04", + "iteration_limit": 10, + "module_index": 4, + "module_kind": "source", + "termination_reason": "module_coverage_threshold_reached" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_05", + "iteration_limit": 10, + "module_index": 5, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 6, + "branch_name": "generated_module_06", + "iteration_limit": 10, + "module_index": 6, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 3, + "branch_name": "generated_upstream", + "iteration_limit": 10, + "module_index": 7, + "module_kind": "tests", + "termination_reason": "module_coverage_threshold_reached" + } + ], + "repository": "lbcb-sci/racon" +} diff --git a/lbcb-sci--racon.a2cfcac/tests/test.sh b/lbcb-sci--racon.a2cfcac/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/lbcb-sci--racon.a2cfcac/tests/workspace.tar.gz b/lbcb-sci--racon.a2cfcac/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1a3e2527797fb06c26d9be6076081da7555b11b6 --- /dev/null +++ b/lbcb-sci--racon.a2cfcac/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e9347a36c7f8bbde446b00e7acf4d52292ec2b669e3d6c4f0c81297f01eed09 +size 4200 diff --git a/lbcb-sci--raven.2c3d337/environment/Dockerfile b/lbcb-sci--raven.2c3d337/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..edce77c9eff98ecfdd18ea41d0dd516062fb88d9 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/environment/Dockerfile @@ -0,0 +1,55 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/lbcb-sci--raven.2c3d337/environment/download.sh b/lbcb-sci--raven.2c3d337/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..bbc293e5d65156676bd2139a532df8c3bf90278c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/environment/download.sh @@ -0,0 +1,180 @@ +#!/usr/bin/env bash +# +# download.sh -- ProgramGym networked download stage for lbcb-sci/raven. +# +# This script is SOURCED (source /source_ro/download.sh), so it: +# * runs in the current shell and keeps exported env vars there, +# * takes no positional arguments, +# * must not use a hard process-exit or stderr/redirect suppression in normal +# control flow (a helper handles the sourced-vs-executed fail branch). +# +# It ONLY downloads and unpacks the FetchContent dependencies that the raven +# project pulls from GitHub at configure time, plus installs the zlib dev +# headers (zlib1g-dev) that bioparser requires via find_package(ZLIB). It +# performs NO compilation, linking, testing, or install of built artifacts. +# All dependency URLs/refs and the apt package names are embedded here +# explicitly; it reads no repository file. +# +# The extracted trees are named exactly as FetchContent expects, and the +# matching FETCHCONTENT_SOURCE_DIR_<NAME> variables are exported so that the +# offline build stage runs the project's cmake configure with NO network +# access, using these prefetched trees. + +# Deterministic offline dependency directory. It persists on the container +# rootfs into the offline build stage (outside the read-only /source_ro mount). +if [ -n "${RAVEN_DEPS_DIR:-}" ]; then + DEPS_DIR="$RAVEN_DEPS_DIR" +else + DEPS_DIR="/opt/raven_offline_deps" +fi + +if ! mkdir -p "$DEPS_DIR"; then + DEPS_DIR="${HOME}/raven_offline_deps" + if ! mkdir -p "$DEPS_DIR"; then + printf 'download.sh: ERROR: cannot create dependency directory\n' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi + fi +fi +export RAVEN_DEPS_DIR="$DEPS_DIR" + +# Fail helper: propagates a nonzero status whether we were sourced or executed. +fail() { + printf 'download.sh: ERROR: %s\n' "$1" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# Download and unpack a single dependency into $DEPS_DIR/<name>. +# $1 name - canonical directory name (also the FetchContent name) +# $2 url - codeload tarball URL +# $3 inner_dir - top-level directory created by extracting the tarball +# Idempotent: if <name> already holds a populated tree, it is left untouched. +download_extract() { + local name="$1" + local url="$2" + local inner_dir="$3" + local target="$DEPS_DIR/$name" + local tarball="$DEPS_DIR/.$name.tar.gz" + + if [ -d "$target" ]; then + printf 'download.sh: %s already present, skipping\n' "$name" + return 0 + fi + + printf 'download.sh: fetching %s\n' "$name" + if ! curl --fail --location --silent --show-error -o "$tarball" "$url"; then + printf 'download.sh: ERROR: download failed for %s (%s)\n' "$name" "$url" >&2 + return 1 + fi + + if ! tar -xzf "$tarball" -C "$DEPS_DIR"; then + printf 'download.sh: ERROR: extraction failed for %s\n' "$name" >&2 + return 1 + fi + + if ! mv "$DEPS_DIR/$inner_dir" "$target"; then + printf 'download.sh: ERROR: cannot move %s into place\n' "$name" >&2 + return 1 + fi + + rm -f "$tarball" + printf 'download.sh: %s ready at %s\n' "$name" "$target" + return 0 +} + +# --------------------------------------------------------------------------- +# Collect the raven FetchContent dependency source trees. These are the exact +# pinned tags that the raven / racon / ram configure steps declare. The +# transitive closure is: bioparser, cereal, racon, edlib, ram, spoa, biosoup, +# thread_pool. +# --------------------------------------------------------------------------- +if ! download_extract bioparser \ + "https://codeload.github.com/rvaser/bioparser/tar.gz/3.0.13" \ + "bioparser-3.0.13"; then + fail "bioparser" +fi + +if ! download_extract cereal \ + "https://codeload.github.com/USCiLab/cereal/tar.gz/v1.3.0" \ + "cereal-1.3.0"; then + fail "cereal" +fi + +if ! download_extract racon \ + "https://codeload.github.com/lbcb-sci/racon/tar.gz/library" \ + "racon-library"; then + fail "racon" +fi + +if ! download_extract edlib \ + "https://codeload.github.com/martinsos/edlib/tar.gz/d5774b4" \ + "edlib-d5774b4"; then + fail "edlib" +fi + +if ! download_extract ram \ + "https://codeload.github.com/lbcb-sci/ram/tar.gz/2.2.0" \ + "ram-2.2.0"; then + fail "ram" +fi + +if ! download_extract biosoup \ + "https://codeload.github.com/rvaser/biosoup/tar.gz/0.10.0" \ + "biosoup-0.10.0"; then + fail "biosoup" +fi + +if ! download_extract thread_pool \ + "https://codeload.github.com/rvaser/thread_pool/tar.gz/4.0.0" \ + "thread_pool-4.0.0"; then + fail "thread_pool" +fi + +if ! download_extract spoa \ + "https://codeload.github.com/rvaser/spoa/tar.gz/4.0.8" \ + "spoa-4.0.8"; then + fail "spoa" +fi + +# --------------------------------------------------------------------------- +# zlib is required by bioparser (its build config runs find_package(ZLIB 1.2.8 +# REQUIRED)) for gzip-compressed FASTA/FASTQ input. Install the dev headers and +# static lib if they are not already present. apt-get update MUST run first so +# the package lists are populated; without it apt reports +# "Unable to locate package zlib1g-dev" (this was the previous failure cause). +# --------------------------------------------------------------------------- +if [ ! -f /usr/include/zlib.h ]; then + printf 'download.sh: apt-get update\n' + if ! apt-get update; then + fail "apt-get update" + fi + printf 'download.sh: installing zlib1g-dev\n' + if ! apt-get install -y zlib1g-dev; then + fail "apt-get install zlib1g-dev" + fi +fi + +# --------------------------------------------------------------------------- +# Export the FetchContent source dirs so the offline build's configure uses +# these prefetched trees instead of cloning from GitHub (no network in the +# build stage). bioparser/cereal/biosoup/thread_pool are header-only but their +# trees must still be present for add_subdirectory + the INTERFACE targets. +# --------------------------------------------------------------------------- +export FETCHCONTENT_SOURCE_DIR_BIOPARSER="$DEPS_DIR/bioparser" +export FETCHCONTENT_SOURCE_DIR_CEREAL="$DEPS_DIR/cereal" +export FETCHCONTENT_SOURCE_DIR_RACON="$DEPS_DIR/racon" +export FETCHCONTENT_SOURCE_DIR_EDLIB="$DEPS_DIR/edlib" +export FETCHCONTENT_SOURCE_DIR_RAM="$DEPS_DIR/ram" +export FETCHCONTENT_SOURCE_DIR_BIOSOUP="$DEPS_DIR/biosoup" +export FETCHCONTENT_SOURCE_DIR_THREAD_POOL="$DEPS_DIR/thread_pool" +export FETCHCONTENT_SOURCE_DIR_SPOA="$DEPS_DIR/spoa" + +printf 'download.sh: dependencies staged under %s\n' "$DEPS_DIR" +printf 'download.sh: done\n' diff --git a/lbcb-sci--raven.2c3d337/environment/executable b/lbcb-sci--raven.2c3d337/environment/executable new file mode 100644 index 0000000000000000000000000000000000000000..a7b1a076eb6eac320f5050f47e9859e927c33bfa --- /dev/null +++ b/lbcb-sci--raven.2c3d337/environment/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f5febe9c0a0c981320f22a9c1d5bf66cec7639c6f915e3877050479e8d183b3 +size 3792504 diff --git a/lbcb-sci--raven.2c3d337/environment/harbor_prepare_download_env.sh b/lbcb-sci--raven.2c3d337/environment/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/environment/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lbcb-sci--raven.2c3d337/environment/workspace.tar.gz b/lbcb-sci--raven.2c3d337/environment/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3d38b2e4cccdcabbe985435af0c688b9ad93a83c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/environment/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d33ac48375c20e801aa1ad9dda93c91f3f7c6c4b797f7f761e2cb58efa21b27 +size 2586 diff --git a/lbcb-sci--raven.2c3d337/instruction.md b/lbcb-sci--raven.2c3d337/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d5b15c340df3494d7000811f8fe84ed15e19f2 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/instruction.md @@ -0,0 +1,98 @@ +You are a helpful assistant that can interact with a computer. + +This is a reverse-engineering benchmark. You are given a compiled binary and its documentation. +Your job is to write a new, original codebase from scratch that produces an executable with identical behavior. +You must figure out the behavior solely by running and interacting with the provided binary. +Writing original code based on observed behavior is the entire point of this benchmark. + +Any approach that shortcuts this — finding existing source code, wrapping the binary, +or installing the original tool — does not count as a solution. It will be detected by an +automated judge, marked as a disqualification, and scored as a failure. +The trace will be posted to an online wall of shame. + +<RULES> +## What is not allowed + +### 1. Obtaining source code + +The only source of truth about what the executable does is the executable itself and its +bundled documentation. You must not search the internet, package registries, or any external +source for information about this project's source code. Even if you recognize what the +executable is, you must reimplement it from behavioral observation alone. + +This includes but is not limited to: +- Cloning or browsing the original GitHub repository, its forks, or mirrors +- Downloading the project from package registries: `cargo install <project>`, `go get github.com/<org>/<project>`, `pip install <project>`, `apt-get source <project>`, `npm install <project>`, etc. +- Fetching source tarballs from project websites (e.g., `curl https://lua.org/ftp/lua-5.5.0.tar.gz`) +- Using a package manager to download the project as a dependency and then reading its cached source (e.g., navigating into `~/.cargo/registry/src/` or `$(go env GOPATH)/pkg/mod/`) +- Searching the web for the project's source code or implementation details + +### 2. Wrapping or reusing the original binary + +Your submission must be a genuine reimplementation. The provided `./executable` is for +observation only — your final solution must not depend on it or any other pre-built version +of the same tool at runtime. + +This includes but is not limited to: +- Writing a wrapper script that delegates to the original binary (e.g., `exec zstd "$@"`) +- Installing the tool from a package manager and shimming to it (e.g., `apt-get install nnn && cp $(which nnn) ./executable`) +- Writing a `compile.sh` that simply makes the provided binary executable (`chmod +x ./executable`) or copies it (`cp ./executable ./executable`) +- Building a binary whose main function shells out to an external tool (e.g., `Command::new("miniserve").args(args).exec()`) +- Re-linking prebuilt `.o` object files found in the workspace without writing new source code + +### 3. Binary analysis of the provided executable + +All information about the provided `./executable` must be obtained by interacting with it +through its normal user interface (CLI flags, stdin/stdout, etc.). +- You MUST NOT decompile `./executable` or use disassemblers (objdump, Ghidra, etc.) on it +- You MUST NOT use strace, ltrace, or similar tracing/instrumentation tools on `./executable` + +Note: this restriction applies ONLY to the provided `./executable`. You are free to use any +analysis tools on binaries that you produce yourself during development. + +## What IS allowed + +- Running the executable with any inputs, flags, and arguments to observe its behavior +- Reading any documentation files bundled in the workspace +</RULES> + +## Task context + +We want to write the source code for a given executable. +The executable is located at `./executable` in the workspace root. + +You also have access to the existing documentation. + +## Your task + +Implement the source code to generate an executable of exactly identical behavior as the original. + +No project-specific dependencies are pre-installed. +You do NOT have access to the internet. +**IMPORTANT**: Make sure that the executable(s) and everything else that is an artifact is not committed, i.e., is in your `.gitignore` file. +Finally, commit your changes. + +Make sure that you have a `./compile.sh` file that produces an executable `./executable` in the workspace root. +`compile.sh` should be executable and should install any dependencies needed to compile the executable. +If your compile.sh fails to compile on a fresh checkout, your task has failed. + +## Important: This is a reverse-engineering benchmark + +Your goal is to write original code from scratch that reproduces the executable's behavior. +The only way to learn what the executable does is to run it and read its bundled documentation. + +Any attempt to obtain source code — whether successful or not — or to wrap/reuse the +provided binary will be detected by an automated judge, disqualified, and scored as zero. +See the full rules in the system prompt above. Key points: + +- Do NOT search the internet, clone repos, or download the project from any package registry +- Do NOT wrap, shim, or delegate to the provided `./executable` or any installed version of the same tool +- Do NOT decompile the provided `./executable` or use strace/ltrace on it (analyzing your own binaries is fine) +- You SHOULD extensively test the executable to understand its behavior before writing code. + If you are dealing with a TUI, tmux/libtmux has been installed to help you test/inspect/it. + +## Recommended Workflow + +1. Explore all documentation files +2. Play with the executable to understand its behavior (however, you MUST NOT decompile `./executable` or perform any other form of binary or strace/ltrace analysis on it) +3. Write the source code to implement the behavior diff --git a/lbcb-sci--raven.2c3d337/solution/solve.sh b/lbcb-sci--raven.2c3d337/solution/solve.sh new file mode 100644 index 0000000000000000000000000000000000000000..a9bbc241bd1280a884f27762b502ff8f4c95635b --- /dev/null +++ b/lbcb-sci--raven.2c3d337/solution/solve.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +# Oracle-only ceiling check. The reference is execute-only for normal agents; +# because the oracle runs as the owning `agent` user it can temporarily add read +# permission and encode the binary for Harbor's normal artifact handoff. +set -euo pipefail +test -f ./executable +chmod u+r ./executable +python3 - <<'PY' +import base64 +from pathlib import Path + +Path(".programgym_oracle_reference").write_bytes( + base64.b64encode(Path("executable").read_bytes()) +) +PY +chmod u-r ./executable +cat > compile.sh <<'EOF' +#!/usr/bin/env bash +set -euo pipefail +if [ -f ./.programgym_oracle_reference ]; then + python3 - <<'PY' +import base64 +from pathlib import Path + +Path("executable").write_bytes( + base64.b64decode(Path(".programgym_oracle_reference").read_bytes()) +) +PY +fi +test -f ./executable +chmod +x ./executable +EOF +chmod +x compile.sh diff --git a/lbcb-sci--raven.2c3d337/task.toml b/lbcb-sci--raven.2c3d337/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5905286d7a902256fff1c08c8a3f68499436802c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/task.toml @@ -0,0 +1,69 @@ +schema_version = "1.3" +source = "ProgramGym" +artifacts = [ + "/logs/verifier/programgym_eval.json", + "/logs/verifier/harbor_diagnostics.json", + "/logs/verifier/programgym_eval.log", + "/logs/verifier/reward.json", + "/logs/verifier/reward.txt", + # Keep agent/runtime state out of the submission handoff. In particular, + # Claude Code installs an absolute symlink under .local/bin; transferring it + # makes Python's safe tar extraction reject the entire workspace archive. + { source = "/workspace", exclude = [ + "executable", + ".git", + ".bashrc", + ".cache", + ".cc-switch", + ".claude", + ".local", + ] }, +] + +[task] +name = "programgym/lbcb-sci--raven.2c3d337" +description = "Synthetic ProgramGym cleanroom reconstruction task for lbcb-sci/raven" +authors = [{ name = "Harbor ProgramGym Synthetic Adapter" }] +keywords = ["programgym", "synthetic", "reverse-engineering", "cleanroom", "cpp"] + +[metadata] +source = "ProgramGym" +instance_id = "lbcb-sci__raven.2c3d337" +repository = "lbcb-sci/raven" +commit = "2c3d33740d04989062170ee6e241fb640071621c" +language = "cpp" +difficulty = "easy" +difficulty_score = 1.6908160579809155 +test_branches = 4 +test_count = 396 + +[agent] +timeout_sec = 14400 +user = "agent" +network_mode = "allowlist" +allowed_hosts = ["api.anthropic.com", "api.openai.com"] + +[verifier] +timeout_sec = 7200 +user = "root" +environment_mode = "separate" + +[verifier.env] +PROGRAMGYM_XDIST_WORKERS = "8" + +[verifier.environment] +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" + +[environment] +network_mode = "public" +build_timeout_sec = 1800 +cpus = 8 +memory_mb = 16384 +storage_mb = 30720 +gpus = 0 +workdir = "/workspace" diff --git a/lbcb-sci--raven.2c3d337/tests/Dockerfile b/lbcb-sci--raven.2c3d337/tests/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..76cacca3a4006591209a34f93e00d4142b6fe407 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/Dockerfile @@ -0,0 +1,63 @@ +FROM ubuntu:22.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip autoconf automake gettext file binutils g++ libtool libncurses-dev meson ninja-build unzip wget curl xz-utils bzip2 zip zstd patch python3-pytest python3-pytest-xdist python3-coverage tar && rm -rf /var/lib/apt/lists/* +ARG CMAKE_VERSION=3.31.12 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) CMAKE_ARCH="x86_64" ;; arm64) CMAKE_ARCH="aarch64" ;; *) echo "unsupported architecture for CMake: ${ARCH}" >&2; exit 1 ;; esac; curl -fsSL -o /tmp/cmake.tar.gz "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${CMAKE_ARCH}.tar.gz"; rm -rf /opt/cmake; mkdir -p /opt/cmake; tar -xzf /tmp/cmake.tar.gz --strip-components=1 -C /opt/cmake; ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake; ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest; ln -sf /opt/cmake/bin/cpack /usr/local/bin/cpack; rm -f /tmp/cmake.tar.gz; cmake --version +ARG GCC_VERSION=13.3.0 +RUN set -eux; ARCH="$(dpkg --print-architecture)"; case "${ARCH}" in amd64) GCC_ARCH="x64" ;; arm64) GCC_ARCH="arm64" ;; *) echo "unsupported architecture for GCC 13: ${ARCH}" >&2; exit 1 ;; esac; wget -O /tmp/gcc.tar.gz "https://github.com/xpack-dev-tools/gcc-xpack/releases/download/v13.3.0-2/xpack-gcc-13.3.0-2-linux-${GCC_ARCH}.tar.gz"; rm -rf /opt/gcc-13; mkdir -p /opt/gcc-13; tar -xzf /tmp/gcc.tar.gz --strip-components=1 -C /opt/gcc-13; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/c++; ln -sf /opt/gcc-13/bin/gcc /usr/local/bin/gcc-13; ln -sf /opt/gcc-13/bin/g++ /usr/local/bin/g++-13; for PROGRAMGYM_GCOV_TOOL in gcov gcov-dump gcov-tool; do if [ -x "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" ]; then ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/local/bin/${PROGRAMGYM_GCOV_TOOL}-13"; ln -sf "/opt/gcc-13/bin/${PROGRAMGYM_GCOV_TOOL}" "/usr/bin/${PROGRAMGYM_GCOV_TOOL}"; fi; done; ln -sf /opt/gcc-13/bin/gcc /usr/bin/gcc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/g++; ln -sf /opt/gcc-13/bin/gcc /usr/bin/cc; ln -sf /opt/gcc-13/bin/g++ /usr/bin/c++; rm -f /tmp/gcc.tar.gz; gcc --version; g++ --version; gcov --version; command -v gcov-dump >/dev/null && gcov-dump --version | head -n 1 || true +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +COPY harbor_prepare_download_env.sh /tmp/harbor_prepare_download_env.sh +RUN chmod 755 /tmp/harbor_prepare_download_env.sh \ + && /bin/bash /tmp/harbor_prepare_download_env.sh \ + && rm -f /workspace/download.sh \ + && rm -f /tmp/harbor_prepare_download_env.sh +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor uses tests/ as the separate verifier build context. Start with the +# same toolchain as the agent, then remove every cleanroom workspace artifact. +RUN rm -rf /workspace/* /workspace/.[!.]* 2>/dev/null || true \ + && mkdir -p /workspace /tests + +# Synthetic cleanroom Dockerfiles commonly install Ubuntu's pytest-xdist 2.5.0. +# Installing a newer pytest alone leaves that apt package importable and creates +# an incompatible mixed apt/pip stack (xdist 2.5 imports the removed py.log). +# Install and constrain the verifier test runner as one coherent pip toolchain. +RUN printf 'pytest<9\n' > /etc/pip-constraint.txt +ENV PIP_CONSTRAINT=/etc/pip-constraint.txt +RUN python3 -m pip install --no-cache-dir --disable-pip-version-check \ + 'pytest<9' 'pytest-xdist>=3,<4' pytest-rerunfailures pytest-timeout + +COPY test.sh /tests/test.sh +COPY programgym_evaluator.py /tests/programgym_evaluator.py +COPY programgym_task.json /tests/programgym_task.json +COPY blobs/ /tests/blobs/ +RUN chmod +x /tests/test.sh diff --git a/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_01.tar.gz b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_01.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3d4e681b096592480f0c57cb5c73bc42281a643c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_01.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5a070eea228adf02afd501b4f54396aa2bc3b4245b83eb70072ea9c9fb88595c +size 31616 diff --git a/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_02.tar.gz b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_02.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0ded9258c64d17b499bb844b914889cf17b04c75 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_02.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bcb7814e361d17a42050e9798120a62a50b5b34d490c994fd64cde2259fb8117 +size 1266733 diff --git a/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_03.tar.gz b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_03.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..510206e380b03e49200fa106a7db6d9a8e8ffed8 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_03.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:20e158a88b7367454b7f262d27c895abc5835d20ffb11ccb28a8d9f5920c93d5 +size 4808483 diff --git a/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_04.tar.gz b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_04.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..076abb6c05d4cf134cc833bf144508804a303214 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/blobs/tests/generated_module_04.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e04738f56f8f650073cdc035e57a1faf8df694a5f70525d4780b29a220abc681 +size 20838 diff --git a/lbcb-sci--raven.2c3d337/tests/download.sh b/lbcb-sci--raven.2c3d337/tests/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..bbc293e5d65156676bd2139a532df8c3bf90278c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/download.sh @@ -0,0 +1,180 @@ +#!/usr/bin/env bash +# +# download.sh -- ProgramGym networked download stage for lbcb-sci/raven. +# +# This script is SOURCED (source /source_ro/download.sh), so it: +# * runs in the current shell and keeps exported env vars there, +# * takes no positional arguments, +# * must not use a hard process-exit or stderr/redirect suppression in normal +# control flow (a helper handles the sourced-vs-executed fail branch). +# +# It ONLY downloads and unpacks the FetchContent dependencies that the raven +# project pulls from GitHub at configure time, plus installs the zlib dev +# headers (zlib1g-dev) that bioparser requires via find_package(ZLIB). It +# performs NO compilation, linking, testing, or install of built artifacts. +# All dependency URLs/refs and the apt package names are embedded here +# explicitly; it reads no repository file. +# +# The extracted trees are named exactly as FetchContent expects, and the +# matching FETCHCONTENT_SOURCE_DIR_<NAME> variables are exported so that the +# offline build stage runs the project's cmake configure with NO network +# access, using these prefetched trees. + +# Deterministic offline dependency directory. It persists on the container +# rootfs into the offline build stage (outside the read-only /source_ro mount). +if [ -n "${RAVEN_DEPS_DIR:-}" ]; then + DEPS_DIR="$RAVEN_DEPS_DIR" +else + DEPS_DIR="/opt/raven_offline_deps" +fi + +if ! mkdir -p "$DEPS_DIR"; then + DEPS_DIR="${HOME}/raven_offline_deps" + if ! mkdir -p "$DEPS_DIR"; then + printf 'download.sh: ERROR: cannot create dependency directory\n' >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi + fi +fi +export RAVEN_DEPS_DIR="$DEPS_DIR" + +# Fail helper: propagates a nonzero status whether we were sourced or executed. +fail() { + printf 'download.sh: ERROR: %s\n' "$1" >&2 + if [ "${BASH_SOURCE[0]}" != "$0" ]; then + return 1 + else + exit 1 + fi +} + +# Download and unpack a single dependency into $DEPS_DIR/<name>. +# $1 name - canonical directory name (also the FetchContent name) +# $2 url - codeload tarball URL +# $3 inner_dir - top-level directory created by extracting the tarball +# Idempotent: if <name> already holds a populated tree, it is left untouched. +download_extract() { + local name="$1" + local url="$2" + local inner_dir="$3" + local target="$DEPS_DIR/$name" + local tarball="$DEPS_DIR/.$name.tar.gz" + + if [ -d "$target" ]; then + printf 'download.sh: %s already present, skipping\n' "$name" + return 0 + fi + + printf 'download.sh: fetching %s\n' "$name" + if ! curl --fail --location --silent --show-error -o "$tarball" "$url"; then + printf 'download.sh: ERROR: download failed for %s (%s)\n' "$name" "$url" >&2 + return 1 + fi + + if ! tar -xzf "$tarball" -C "$DEPS_DIR"; then + printf 'download.sh: ERROR: extraction failed for %s\n' "$name" >&2 + return 1 + fi + + if ! mv "$DEPS_DIR/$inner_dir" "$target"; then + printf 'download.sh: ERROR: cannot move %s into place\n' "$name" >&2 + return 1 + fi + + rm -f "$tarball" + printf 'download.sh: %s ready at %s\n' "$name" "$target" + return 0 +} + +# --------------------------------------------------------------------------- +# Collect the raven FetchContent dependency source trees. These are the exact +# pinned tags that the raven / racon / ram configure steps declare. The +# transitive closure is: bioparser, cereal, racon, edlib, ram, spoa, biosoup, +# thread_pool. +# --------------------------------------------------------------------------- +if ! download_extract bioparser \ + "https://codeload.github.com/rvaser/bioparser/tar.gz/3.0.13" \ + "bioparser-3.0.13"; then + fail "bioparser" +fi + +if ! download_extract cereal \ + "https://codeload.github.com/USCiLab/cereal/tar.gz/v1.3.0" \ + "cereal-1.3.0"; then + fail "cereal" +fi + +if ! download_extract racon \ + "https://codeload.github.com/lbcb-sci/racon/tar.gz/library" \ + "racon-library"; then + fail "racon" +fi + +if ! download_extract edlib \ + "https://codeload.github.com/martinsos/edlib/tar.gz/d5774b4" \ + "edlib-d5774b4"; then + fail "edlib" +fi + +if ! download_extract ram \ + "https://codeload.github.com/lbcb-sci/ram/tar.gz/2.2.0" \ + "ram-2.2.0"; then + fail "ram" +fi + +if ! download_extract biosoup \ + "https://codeload.github.com/rvaser/biosoup/tar.gz/0.10.0" \ + "biosoup-0.10.0"; then + fail "biosoup" +fi + +if ! download_extract thread_pool \ + "https://codeload.github.com/rvaser/thread_pool/tar.gz/4.0.0" \ + "thread_pool-4.0.0"; then + fail "thread_pool" +fi + +if ! download_extract spoa \ + "https://codeload.github.com/rvaser/spoa/tar.gz/4.0.8" \ + "spoa-4.0.8"; then + fail "spoa" +fi + +# --------------------------------------------------------------------------- +# zlib is required by bioparser (its build config runs find_package(ZLIB 1.2.8 +# REQUIRED)) for gzip-compressed FASTA/FASTQ input. Install the dev headers and +# static lib if they are not already present. apt-get update MUST run first so +# the package lists are populated; without it apt reports +# "Unable to locate package zlib1g-dev" (this was the previous failure cause). +# --------------------------------------------------------------------------- +if [ ! -f /usr/include/zlib.h ]; then + printf 'download.sh: apt-get update\n' + if ! apt-get update; then + fail "apt-get update" + fi + printf 'download.sh: installing zlib1g-dev\n' + if ! apt-get install -y zlib1g-dev; then + fail "apt-get install zlib1g-dev" + fi +fi + +# --------------------------------------------------------------------------- +# Export the FetchContent source dirs so the offline build's configure uses +# these prefetched trees instead of cloning from GitHub (no network in the +# build stage). bioparser/cereal/biosoup/thread_pool are header-only but their +# trees must still be present for add_subdirectory + the INTERFACE targets. +# --------------------------------------------------------------------------- +export FETCHCONTENT_SOURCE_DIR_BIOPARSER="$DEPS_DIR/bioparser" +export FETCHCONTENT_SOURCE_DIR_CEREAL="$DEPS_DIR/cereal" +export FETCHCONTENT_SOURCE_DIR_RACON="$DEPS_DIR/racon" +export FETCHCONTENT_SOURCE_DIR_EDLIB="$DEPS_DIR/edlib" +export FETCHCONTENT_SOURCE_DIR_RAM="$DEPS_DIR/ram" +export FETCHCONTENT_SOURCE_DIR_BIOSOUP="$DEPS_DIR/biosoup" +export FETCHCONTENT_SOURCE_DIR_THREAD_POOL="$DEPS_DIR/thread_pool" +export FETCHCONTENT_SOURCE_DIR_SPOA="$DEPS_DIR/spoa" + +printf 'download.sh: dependencies staged under %s\n' "$DEPS_DIR" +printf 'download.sh: done\n' diff --git a/lbcb-sci--raven.2c3d337/tests/executable b/lbcb-sci--raven.2c3d337/tests/executable new file mode 100644 index 0000000000000000000000000000000000000000..a7b1a076eb6eac320f5050f47e9859e927c33bfa --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/executable @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f5febe9c0a0c981320f22a9c1d5bf66cec7639c6f915e3877050479e8d183b3 +size 3792504 diff --git a/lbcb-sci--raven.2c3d337/tests/harbor_prepare_download_env.sh b/lbcb-sci--raven.2c3d337/tests/harbor_prepare_download_env.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c7dd2f2b8fff5fb8926261279d38518e59e407c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/harbor_prepare_download_env.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail +cd /workspace +set -a +source /workspace/download.sh +set +a +python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh +import os +import shlex + +ignored = { + "ALL_PROXY", + "HTTP_PROXY", + "HTTPS_PROXY", + "NO_PROXY", + "OLDPWD", + "PIP_PROXY", + "PWD", + "SHLVL", + "_", + "all_proxy", + "http_proxy", + "https_proxy", + "no_proxy", + "pip_proxy", +} +for key in sorted(os.environ): + if key in ignored or key.startswith("BASH_FUNC_"): + continue + value = os.environ[key] + if "\n" in value: + continue + print(f"export {key}={shlex.quote(value)}") +PY diff --git a/lbcb-sci--raven.2c3d337/tests/programgym_evaluator.py b/lbcb-sci--raven.2c3d337/tests/programgym_evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..541bda3a105013fbffd2e0d69261ed76b40a7992 --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/programgym_evaluator.py @@ -0,0 +1,1201 @@ +#!/usr/bin/env python3 +"""In-place ProgramGym evaluator. + +Mirrors ProgramGym's ``Evaluator`` pipeline as closely as a single-container, +no-Docker-in-Docker host allows. Run from ``tests/test.sh`` inside the agent's +cleanroom container after Harbor flips the verifier-phase network policy. + +Differences from ``programgym.eval.eval.Evaluator`` that are structural to +running in one container: + +* No fresh container per branch. ``snapshot_workspace`` / ``restore_workspace`` + copy a post-compile workspace snapshot to a temp directory and restore it + before each branch; ``cleanup_lingering_processes`` kills leftover branch + processes between attempts to approximate the fresh-container boundary. +* No ``docker commit``. The post-compile workspace snapshot serves the same + role as the committed image upstream. +* Hidden test blobs are fetched on demand from HuggingFace via + ``huggingface_hub.snapshot_download`` (matching ``programgym.utils.blob_store``) + rather than being pre-staged into ``/tests/blobs/``. Override with + ``PROGRAMGYM_BLOB_DIR`` for offline reruns. + +Everything else (eval_clean_hashes scrub, deterministic synthetic git seed, +``compile.sh`` then stash + hash the executable, best-effort +``pytest-rerunfailures``, per-branch test-tar overlay, executable hash +``--max-worker-restart=4``, xdist worker-crash retry with serial fallback, +best-of-N attempt selection, active vs ignored test bookkeeping, scoring) is +preserved. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import shlex +import shutil +import signal +import subprocess +import tempfile +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any + +WORKSPACE = Path(os.environ.get("PROGRAMGYM_WORKSPACE", "/workspace")) +STASHED_EXECUTABLE = Path("/opt/programgym-stashed-executable-do-not-modify") +METADATA_PATH = Path( + os.environ.get("PROGRAMGYM_METADATA", "/tests/programgym_task.json") +) +LOG_DIR = Path(os.environ.get("PROGRAMGYM_LOG_DIR", "/logs/verifier")) +WORKER_CRASH_PHRASE = "worker '" +XDIST_COLLAPSE_MARKERS = ( + "maximum crashed workers reached", + "xdist: maximum crashed", +) + +DEFAULT_HF_REPO_ID = "programgym/ProgramGym-Tests" +DEFAULT_HF_REVISION = "main" + +# Oracle agent handoff files (see solution/solve.sh). Must not appear in the +# post-compile workspace snapshot or they pollute tree-scanning tests (dutree). +_ORACLE_HANDOFF_NAMES = (".programgym_oracle_reference",) + +_TOOLCHAIN_BIN_DIR_CANDIDATES = ( + "/usr/local/go/bin", + "/go/bin", + "/usr/local/cargo/bin", + "/root/.cargo/bin", + "/root/.ghcup/bin", +) + + +def toolchain_bin_dirs() -> list[str]: + """Return toolchain bin directories that exist on this image.""" + candidates = list(_TOOLCHAIN_BIN_DIR_CANDIDATES) + candidates.extend( + str(path) + for path in sorted(Path("/usr/lib").glob("go-*/bin")) + if _is_accessible_dir(path) + ) + seen: set[str] = set() + present: list[str] = [] + for path in candidates: + if path in seen: + continue + seen.add(path) + if _is_accessible_dir(path): + present.append(path) + return present + + +def _is_accessible_dir(path: str | Path) -> bool: + """Return whether path is a directory without failing on protected homes.""" + try: + return Path(path).is_dir() + except OSError: + return False + + +def bootstrap_toolchain_path() -> str: + """Prepend discovered toolchain dirs to PATH (idempotent).""" + prepend = toolchain_bin_dirs() + current_parts = [part for part in os.environ.get("PATH", "").split(":") if part] + merged: list[str] = [] + for path in prepend + current_parts: + if path not in merged: + merged.append(path) + new_path = ":".join(merged) + os.environ["PATH"] = new_path + return new_path + + +def _bash_login_command(command: str) -> str: + """Run ``command`` under bash -lc with an explicit PATH export.""" + path = bootstrap_toolchain_path() + return f"export PATH={shlex.quote(path)}; {command}" + + +def sha256(path: Path) -> str: + h = hashlib.sha256() + with path.open("rb") as f: + for chunk in iter(lambda: f.read(1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def write_json(path: Path, data: dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(data, indent=2, sort_keys=True)) + tmp.replace(path) + + +def _read_log_tail(path: Path | None, max_bytes: int = 65536) -> str: + if path is None or not path.exists(): + return "" + data = path.read_bytes() + if len(data) <= max_bytes: + return data.decode(errors="replace") + return data[-max_bytes:].decode(errors="replace") + + +def _close_pipes(proc: subprocess.Popen[Any]) -> None: + for stream in (proc.stdout, proc.stderr): + if stream is not None: + try: + stream.close() + except OSError: + pass + + +def _terminate_process_tree(proc: subprocess.Popen[Any]) -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.kill() + except ProcessLookupError: + pass + + +_PKILL_PATTERNS = ( + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + "tail -f", + "development.log", + " less ", + " less$", + "/less ", +) + + +def _pkill_aggressive() -> str: + """Best-effort kill of branch pytest/subprocess trees (Modal gVisor fallback).""" + notes: list[str] = [] + workspace = str(WORKSPACE) + patterns = list(_PKILL_PATTERNS) + [ + f"pytest.*{workspace}", + f"xdist.*{workspace}", + ] + for pattern in patterns: + result = subprocess.run( + ["pkill", "-9", "-f", pattern], + capture_output=True, + text=True, + ) + notes.append(f"pkill -9 -f {pattern!r}: rc={result.returncode}") + return "\n".join(notes) + + +def run_step( + command: str, + cwd: Path, + *, + timeout: int, + env: dict[str, str] | None = None, + step: str, + accept_failure: bool = False, + log_output: bool | None = None, + max_output_bytes: int = 65536, +) -> dict[str, Any]: + if log_output is None: + log_output = step == "run_tests" or timeout >= 60 + + started = time.monotonic() + stdout_path: Path | None = None + stderr_path: Path | None = None + stdout_f = None + stderr_f = None + + if log_output: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_id = f"{step}-{int(started * 1000)}" + stdout_path = LOG_DIR / f"run-step-{log_id}.stdout.log" + stderr_path = LOG_DIR / f"run-step-{log_id}.stderr.log" + stdout_f = stdout_path.open("w", encoding="utf-8") + stderr_f = stderr_path.open("w", encoding="utf-8") + popen_stdout: Any = stdout_f + popen_stderr: Any = stderr_f + else: + popen_stdout = subprocess.PIPE + popen_stderr = subprocess.PIPE + + proc = subprocess.Popen( + ["bash", "-lc", _bash_login_command(command)], + cwd=cwd, + env={**os.environ, **(env or {})}, + stdout=popen_stdout, + stderr=popen_stderr, + start_new_session=True, + text=True, + ) + timed_out = False + stdout = "" + stderr = "" + try: + if log_output: + proc.wait(timeout=timeout) + else: + stdout, stderr = proc.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + _terminate_process_tree(proc) + cleanup_lingering_processes(aggressive=True) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + if not log_output: + _close_pipes(proc) + finally: + if stdout_f is not None: + stdout_f.close() + if stderr_f is not None: + stderr_f.close() + + if timed_out: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = "" + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": 124, + "exception_info": f"timed out after {timeout}s", + } + else: + if log_output: + output = _read_log_tail(stdout_path, max_output_bytes) + _read_log_tail( + stderr_path, max_output_bytes + ) + else: + output = stdout + stderr + entry = { + "step": step, + "command": command, + "wall_time": time.monotonic() - started, + "output": output, + "returncode": proc.returncode, + "exception_info": "", + } + if entry["returncode"] and not accept_failure: + raise RuntimeError( + f"{step} failed: {entry['exception_info'] or entry['output']}" + ) + return entry + + +def cleanup_lingering_processes(*, aggressive: bool = False) -> dict[str, Any]: + started = time.monotonic() + patterns = [ + str(WORKSPACE / "executable"), + f"{WORKSPACE}/eval/", + f"{WORKSPACE}/tests/", + # lazygit --logs/-l tests spawn `tail -f` outside /workspace/. + "tail -f", + "development.log", + ] + killed: list[int] = [] + proc_root = Path("/proc") + proc_available = proc_root.exists() + if proc_available: + for proc_dir in proc_root.iterdir(): + if not proc_dir.name.isdigit(): + continue + pid = int(proc_dir.name) + if pid in {os.getpid(), os.getppid()}: + continue + try: + raw = (proc_dir / "cmdline").read_bytes() + except (FileNotFoundError, PermissionError, ProcessLookupError): + continue + cmdline = raw.replace(b"\0", b" ").decode(errors="replace") + if not any(pattern in cmdline for pattern in patterns): + continue + try: + os.kill(pid, signal.SIGKILL) + except (PermissionError, ProcessLookupError): + continue + killed.append(pid) + pkill_output = "" + if aggressive or not proc_available: + pkill_output = _pkill_aggressive() + output_parts = [] + if killed: + output_parts.append("\n".join(str(pid) for pid in killed)) + if pkill_output: + output_parts.append(pkill_output) + return { + "step": "cleanup_lingering_processes", + "command": "kill leftover branch processes referencing the workspace", + "wall_time": time.monotonic() - started, + "output": "\n".join(output_parts), + "returncode": 0, + "exception_info": "", + } + + +def extract_trusted_blob(tar_path: Path, dest: Path) -> None: + import tarfile + + with tarfile.open(tar_path, "r:gz") as tf: + try: + tf.extractall(dest, filter="fully_trusted") + except TypeError: + tf.extractall(dest) + + +def find_results_xml() -> Path | None: + """Return the junit xml path if pytest wrote one.""" + for candidate in (WORKSPACE / "eval" / "results.xml", WORKSPACE / "results.xml"): + if candidate.exists(): + return candidate + return None + + +def remove_oracle_handoff_artifacts() -> list[str]: + """Drop oracle-agent handoff files from /workspace before snapshot/restore.""" + removed: list[str] = [] + for name in _ORACLE_HANDOFF_NAMES: + path = WORKSPACE / name + if path.exists(): + if path.is_dir(): + shutil.rmtree(path) + else: + path.unlink() + removed.append(name) + return removed + + +def _remove_tree(path: Path) -> None: + """Remove a file or directory tree, with a shell fallback for overlay races.""" + if path.is_symlink() or path.is_file(): + path.unlink(missing_ok=True) + return + if not path.is_dir(): + path.unlink(missing_ok=True) + return + for attempt in range(3): + try: + shutil.rmtree(path) + if not path.exists(): + return + except OSError: + if attempt == 2: + run_step( + f"rm -rf {shlex.quote(str(path))}", + path.parent, + timeout=120, + step="clear_workspace_fallback", + accept_failure=True, + ) + if not path.exists(): + return + raise + + +def ensure_workspace_dir() -> None: + """Guarantee WORKSPACE exists as a writable directory (not a symlink/file).""" + if WORKSPACE.exists() and not WORKSPACE.is_dir(): + if WORKSPACE.is_symlink() or WORKSPACE.is_file(): + WORKSPACE.unlink() + else: + shutil.rmtree(WORKSPACE) + WORKSPACE.mkdir(parents=True, exist_ok=True) + + +def clear_workspace() -> None: + ensure_workspace_dir() + for path in list(WORKSPACE.iterdir()): + _remove_tree(path) + + +def restore_reference_executable() -> None: + """Write the stashed reference binary into /workspace after a branch overlay. + + Branch blobs may ship ``executable`` as a dangling symlink into + ``target/release/...``; ``shutil.copy2`` would follow it and raise + ``FileNotFoundError``. Drop whatever the blob left and copy the stashed + reference as a regular file. + """ + ensure_workspace_dir() + if not STASHED_EXECUTABLE.is_file(): + raise FileNotFoundError( + f"missing stashed reference executable at {STASHED_EXECUTABLE}" + ) + dest = WORKSPACE / "executable" + if dest.exists() or dest.is_symlink(): + if dest.is_dir(): + shutil.rmtree(dest) + else: + dest.unlink(missing_ok=True) + shutil.copy2(STASHED_EXECUTABLE, dest) + dest.chmod(0o755) + + +def snapshot_workspace(dest: Path) -> None: + if dest.exists(): + shutil.rmtree(dest) + shutil.copytree(WORKSPACE, dest, symlinks=True) + + +def restore_workspace(source: Path) -> None: + clear_workspace() + shutil.copytree(source, WORKSPACE, dirs_exist_ok=True, symlinks=True) + ensure_workspace_dir() + + +def remove_hashed_files(root: Path, hashes: set[str]) -> list[str]: + removed: list[str] = [] + for path in root.rglob("*"): + if path.is_file() and not path.is_symlink(): + try: + if sha256(path) in hashes: + path.unlink() + removed.append(str(path.relative_to(root))) + except OSError: + continue + return removed + + +def branch_tests(branch_info: dict[str, Any]) -> list[str]: + ignored = { + item["name"] for item in branch_info.get("ignored_tests", []) if "name" in item + } + return [name for name in branch_info.get("tests", []) if name not in ignored] + + +def ignored_tests(metadata: dict[str, Any]) -> set[str]: + result: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + result.update( + f"{branch}/{item['name']}" + for item in info.get("ignored_tests", []) + if "name" in item + ) + return result + + +def active_tests(metadata: dict[str, Any]) -> set[str]: + active: set[str] = set() + for branch, info in metadata.get("branches", {}).items(): + if info.get("ignored"): + continue + ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + active.update( + f"{branch}/{name}" for name in info.get("tests", []) if name not in ignored + ) + return active + + +def inject_not_run( + result: dict[str, Any], branch: str, tests: list[str], error_code: str +) -> None: + result["test_results"].extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": error_code}, + } + for name in tests + ) + + +def testcase_name(case: ET.Element) -> str: + classname = case.attrib.get("classname", "") + name = case.attrib.get("name", "") + return f"{classname}.{name}" if classname else name + + +# Only these tags under <testcase> represent a result. <system-out> / +# <system-err> are stdout/stderr captures and must not be treated as results +# (a leading <system-out> followed by <failure> would otherwise be classified +# as a stdout-only "passed"). +JUNIT_RESULT_TAGS = {"skipped", "failure", "error"} + + +def parse_junit( + raw_xml: str, branch: str, expected: list[str], ignored: set[str] +) -> tuple[list[dict[str, Any]], list[str]]: + root = ET.fromstring(raw_xml) + got: set[str] = set() + results: list[dict[str, Any]] = [] + for case in root.iter("testcase"): + name = testcase_name(case) + got.add(name) + extra: dict[str, Any] = {} + if "time" in case.attrib: + try: + extra["time"] = float(case.attrib["time"]) + except ValueError: + extra["time"] = case.attrib["time"] + result_children = [c for c in case if c.tag in JUNIT_RESULT_TAGS] + # Collapse duplicate same-tag result children. Pytest's + # "pytest.internal" pseudo-test sometimes emits two identical <error> + # entries; treating that as a system_error would over-flag a real + # single failure. Mirrors upstream eval.py:816-820. + if len(result_children) > 1 and len({c.tag for c in result_children}) == 1: + result_children = [result_children[0]] + if not result_children: + status = "passed" + elif len(result_children) != 1: + status = "system_error" + extra["error_details"] = ( + f"Expected 1 result for {name}, got {len(result_children)}: " + f"{[c.tag for c in result_children]}" + ) + else: + first = result_children[0] + status = first.tag # "skipped" | "failure" | "error" + extra["message"] = first.attrib.get("message") or "" + if first.text: + extra["text"] = first.text + results.append( + {"name": name, "branch": branch, "status": status, "extra": extra} + ) + + active_expected = [name for name in expected if name not in ignored] + missing = [name for name in active_expected if name not in got] + results.extend( + { + "name": name, + "branch": branch, + "status": "not_run", + "extra": {"error_code": "missing_from_junit_xml"}, + } + for name in missing + ) + unexpected = got - set(expected) - ignored + warnings = ( + [f"Branch {branch}: {len(unexpected)} test(s) in JUnit XML not in tests.json"] + if unexpected + else [] + ) + return results, warnings + + +def count_worker_crashes(raw_xml: str) -> int: + if WORKER_CRASH_PHRASE not in raw_xml: + return 0 + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + crashes = 0 + for case in root.iter("testcase"): + for child in case: + text = (child.get("message") or "") + " " + (child.text or "") + if ( + child.tag in {"error", "failure"} + and WORKER_CRASH_PHRASE in text + and "crashed" in text + ): + crashes += 1 + break + return crashes + + +def run_output_indicates_xdist_collapse(output: str) -> bool: + lower = output.lower() + return any(marker in lower for marker in XDIST_COLLAPSE_MARKERS) + + +def count_junit_failures(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + failures = 0 + for case in root.iter("testcase"): + for child in case: + if child.tag in {"failure", "error"}: + failures += 1 + break + return failures + + +def count_junit_passed(raw_xml: str) -> int: + try: + root = ET.fromstring(raw_xml) + except ET.ParseError: + return 0 + passed = 0 + for case in root.iter("testcase"): + if not any(child.tag in JUNIT_RESULT_TAGS for child in case): + passed += 1 + return passed + + +def branch_attempt_metrics( + raw_xml: str, *, run_output: str, expected_tests: int +) -> tuple[int, int, int, int]: + """Return (crashes, n_testcases, failures, missing_from_xml).""" + crashes = count_worker_crashes(raw_xml) + if run_output_indicates_xdist_collapse(run_output): + crashes = max(crashes, 1) + n_tests = count_testcases(raw_xml) + failures = count_junit_failures(raw_xml) + missing = max(0, expected_tests - n_tests) + return crashes, n_tests, failures, missing + + +def needs_serial_retry( + *, + serial: bool, + crashes: int, + missing: int, + failures: int, + n_tests: int, + expected_tests: int, + run_output: str, +) -> bool: + if serial: + return False + high_failure_rate = ( + expected_tests > 0 and n_tests >= expected_tests and failures / n_tests >= 0.8 + ) + return ( + crashes > 0 + or missing > 0 + or high_failure_rate + or run_output_indicates_xdist_collapse(run_output) + ) + + +def count_testcases(raw_xml: str) -> int: + try: + return sum(1 for _ in ET.fromstring(raw_xml).iter("testcase")) + except ET.ParseError: + return 0 + + +def scored_results( + result: dict[str, Any], metadata: dict[str, Any] +) -> list[dict[str, Any]]: + active = active_tests(metadata) + by_key = { + f"{test['branch']}/{test['name']}": test + for test in result["test_results"] + if f"{test['branch']}/{test['name']}" in active + } + return [ + by_key.get( + key, + { + "branch": key.split("/", 1)[0], + "name": key.split("/", 1)[1], + "status": "not_run", + "extra": {"error_code": "missing_from_results"}, + }, + ) + for key in sorted(active) + ] + + +def summarize(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + # Multi-key reward: Harbor's default Mean aggregates each key independently + # (see harbor.metrics.base.aggregate_reward_dicts), so mean("resolved") is + # the proportion of tasks scoring a perfect pass-rate and mean of + # "almost_resolved" is the proportion scoring >= 0.95. "reward" stays the + # per-task pass-rate whose mean is the overall mean reward. + return { + "reward": pass_rate, + "resolved": 1.0 if pass_rate >= 1.0 else 0.0, + "almost_resolved": 1.0 if pass_rate >= 0.95 else 0.0, + } + + +def diagnostics(result: dict[str, Any], metadata: dict[str, Any]) -> dict[str, Any]: + scored = scored_results(result, metadata) + n_passed = sum(t["status"] == "passed" for t in scored) + n_tests = len(scored) + pass_rate = n_passed / n_tests if n_tests else 0.0 + return { + "pass_rate": pass_rate, + "resolved": int( + bool( + n_tests + and n_passed == n_tests + and not result["test_branch_errors"] + and not result["error_code"] + ) + ), + "n_passed": n_passed, + "n_tests": n_tests, + "n_branch_errors": len(result["test_branch_errors"]), + "infra_error": int(bool(result["error_code"] or result["test_branch_errors"])), + "executable_hash_present": int(bool(result.get("executable_hash"))), + } + + +def use_script_pty() -> bool: + return os.environ.get("PROGRAMGYM_SCRIPT_PTY", "").strip() == "1" + + +def script_pty_available() -> bool: + return shutil.which("script") is not None + + +def branch_env( + *, + serial: bool, + has_rerunfailures: bool, + extras: dict[str, str] | None = None, +) -> dict[str, str]: + addopts = ["--max-worker-restart=4"] + # A serial fallback is already a complete second execution. Re-running each + # failing test two more times makes large, failure-heavy suites prohibitively + # slow and adds little signal. + if has_rerunfailures and not serial: + addopts.extend(["--reruns=2", "--reruns-delay=1"]) + env = { + "PYTEST_ADDOPTS": " ".join(addopts), + # Match upstream non-TTY regression environments (dirble log format, etc.). + "NO_COLOR": "1", + "TERM": "dumb", + "CLICOLOR": "0", + "CLICOLOR_FORCE": "0", + "COLORTERM": "", + } + if extras: + env.update(extras) + xdist_workers = os.environ.get("PROGRAMGYM_XDIST_WORKERS") + if serial: + xdist_workers = "1" + if xdist_workers: + env["PYTEST_XDIST_AUTO_NUM_WORKERS"] = xdist_workers + return env + + +_SERIAL_RUN_SH = ".programgym_run_serial.sh" +# ``eval/run.sh`` usually passes ``-n auto`` on the command line, which overrides +# ``PYTEST_ADDOPTS``. Rewrite to ``-n 0`` in a verifier-local copy for retries. +_RUN_SH_XDIST_RE = re.compile(r"-n\s*(?:auto|\d+)") + + +def prepare_serial_run_sh(run_sh: Path) -> Path: + """Write a serial-only copy of ``eval/run.sh`` with xdist disabled.""" + serial_sh = run_sh.with_name(_SERIAL_RUN_SH) + patched = _RUN_SH_XDIST_RE.sub("-n 0", run_sh.read_text()) + serial_sh.write_text(patched) + serial_sh.chmod(0o755) + return serial_sh + + +def run_tests_command(*, serial: bool) -> str: + if serial: + inner = f"chmod +x ./eval/{_SERIAL_RUN_SH} && ./eval/{_SERIAL_RUN_SH}" + else: + inner = "chmod +x ./eval/run.sh && ./eval/run.sh" + if use_script_pty() and script_pty_available(): + return f"script -q -c {shlex.quote(inner)} /dev/null" + return inner + + +BAKED_BLOB_DIR = Path(os.environ.get("PROGRAMGYM_BAKED_BLOB_DIR", "/tests/blobs")) + + +def resolve_blob_dir(instance_id: str, metadata: dict[str, Any]) -> Path: + """Locate the per-instance blob directory. + + Resolution order: + + 1. ``/tests/blobs/`` if pre-fetched into the task at generation time + (``programgym-adapter --download-blobs``). Verifier-only mount, so + agent never sees these. + 2. ``PROGRAMGYM_BLOB_DIR`` env override pointing at an HF-cache-shaped + tree on disk (``<dir>/<instance_id>/tests/<branch>.tar.gz``). Useful + for offline reruns sharing a cache across many tasks. + 3. ``huggingface_hub.snapshot_download`` from + ``programgym/ProgramGym-Tests`` (default repo, ``main`` revision). + + The returned directory contains ``tests/<branch>.tar.gz`` per active + branch — same shape as ``programgym/ProgramGym-Tests/<instance_id>/`` + on HF. + """ + if BAKED_BLOB_DIR.exists() and (BAKED_BLOB_DIR / "tests").exists(): + return BAKED_BLOB_DIR + + local = os.environ.get("PROGRAMGYM_BLOB_DIR", "").strip() + if local: + candidate = Path(local) / instance_id + if candidate.exists(): + return candidate + raise FileNotFoundError( + f"PROGRAMGYM_BLOB_DIR set but {candidate} does not exist" + ) + + repo_id = os.environ.get("PROGRAMGYM_HF_REPO") or metadata.get( + "hf_repo_id", DEFAULT_HF_REPO_ID + ) + revision = os.environ.get("PROGRAMGYM_HF_REVISION") or metadata.get( + "hf_revision", DEFAULT_HF_REVISION + ) + + from huggingface_hub import snapshot_download + + cache_root = Path( + snapshot_download( + repo_id, + repo_type="dataset", + revision=revision, + allow_patterns=f"{instance_id}/**", + ) + ) + blob_dir = cache_root / instance_id + if not blob_dir.exists(): + raise FileNotFoundError( + f"HF blob directory missing for {instance_id} at {blob_dir}" + ) + return blob_dir + + +def evaluate(metadata: dict[str, Any]) -> dict[str, Any]: + bootstrap_toolchain_path() + branches = metadata.get("branches", {}) + active_branch_items = [ + (name, info) for name, info in branches.items() if not info.get("ignored") + ] + result: dict[str, Any] = { + "test_results": [], + "error_code": None, + "error_details": None, + "log": [], + "solution_branch": "submission", + "test_branches": [name for name, _ in active_branch_items], + "test_branch_errors": {}, + "executable_hash": None, + "warnings": [], + } + + instance_id = metadata["instance_id"] + + compile_timeout = int(os.environ.get("PROGRAMGYM_COMPILE_TIMEOUT", "900")) + branch_timeout = int(os.environ.get("PROGRAMGYM_BRANCH_TIMEOUT", "3600")) + + def fail_all(error_code: str, details: str) -> dict[str, Any]: + result["error_code"] = error_code + result["error_details"] = details + for branch, info in active_branch_items: + inject_not_run(result, branch, branch_tests(info), error_code) + return result + + with tempfile.TemporaryDirectory(prefix="programgym-eval-") as tmp: + compiled_snapshot = Path(tmp) / "compiled" + + started = time.monotonic() + removed = remove_hashed_files( + WORKSPACE, set(metadata.get("eval_clean_hashes", [])) + ) + result["log"].append( + { + "step": "remove_hashed_files", + "command": "remove files matching eval_clean_hashes", + "wall_time": time.monotonic() - started, + "output": "".join(f"removed '{path}'\n" for path in removed), + "returncode": 0, + "exception_info": "", + } + ) + + compile_sh = WORKSPACE / "compile.sh" + if not compile_sh.exists(): + return fail_all( + "missing_compile_sh", "submission did not contain compile.sh" + ) + + seed = ( + "if [ ! -d .git ]; then " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c init.defaultBranch=gold init -q && " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false add -A && " + "GIT_AUTHOR_DATE='2000-01-01T00:00:00Z' " + "GIT_COMMITTER_DATE='2000-01-01T00:00:00Z' " + "git -c user.email=gold@local -c user.name=gold -c commit.gpgsign=false commit -q --allow-empty -m gold; " + "fi" + ) + try: + result["log"].append( + run_step(seed, WORKSPACE, timeout=300, step="seed_git") + ) + compile_log = run_step( + "chmod +x ./compile.sh && ./compile.sh", + WORKSPACE, + timeout=compile_timeout, + step="compile", + accept_failure=True, + ) + result["log"].append(compile_log) + if compile_log["returncode"]: + return fail_all("compile_failed", compile_log["output"]) + executable = WORKSPACE / "executable" + if not executable.exists(): + return fail_all( + "missing_executable", + "compile.sh completed but did not create ./executable", + ) + STASHED_EXECUTABLE.parent.mkdir(parents=True, exist_ok=True) + # `move` (not copy) so /workspace doesn't keep a parallel copy of + # the agent's executable during the stash→restore window. Mirrors + # upstream `mv ./executable {STASHED}` (eval.py:472). + shutil.move(str(executable), STASHED_EXECUTABLE) + result["executable_hash"] = sha256(STASHED_EXECUTABLE) + result["log"].append( + run_step( + "pip3 install -q --disable-pip-version-check pytest-rerunfailures", + WORKSPACE, + timeout=120, + step="install_rerunfailures", + accept_failure=True, + ) + ) + has_rerunfailures = result["log"][-1]["returncode"] == 0 + handoff_removed = remove_oracle_handoff_artifacts() + if handoff_removed: + result["log"].append( + { + "step": "remove_oracle_handoff", + "command": "remove oracle handoff artifacts from workspace", + "wall_time": 0.0, + "output": "".join( + f"removed '{name}'\n" for name in handoff_removed + ), + "returncode": 0, + "exception_info": "", + } + ) + snapshot_workspace(compiled_snapshot) + except Exception as exc: + return fail_all(type(exc).__name__, str(exc)) + + try: + blob_dir = resolve_blob_dir(instance_id, metadata) + except Exception as exc: + details = f"{type(exc).__name__}: {exc}" + for branch, info in active_branch_items: + result["test_branch_errors"][branch] = [ + { + "error_code": "blob_resolution_failed", + "error_details": details, + } + ] + inject_not_run( + result, branch, branch_tests(info), "blob_resolution_failed" + ) + return result + + for branch, info in active_branch_items: + tests = branch_tests(info) + blob = blob_dir / "tests" / f"{branch}.tar.gz" + if not blob.exists(): + result["test_branch_errors"][branch] = [ + {"error_code": "missing_test_blob", "error_details": blob.name} + ] + inject_not_run(result, branch, tests, "missing_test_blob") + continue + + best_xml = "" + # Prefer a complete, clean XML result, then the result covering the + # most expected tests, and only then the one with the most passes. + # Pass-count-only ranking can retain a partial xdist result over a + # complete serial result. + best_quality = (-1, -1, -1) + serial = bool(metadata.get("force_serial_branches")) + branch_log: list[dict[str, Any]] = [] + branch_ignored = { + item["name"] for item in info.get("ignored_tests", []) if "name" in item + } + n_expected = len([name for name in tests if name not in branch_ignored]) + + def merge_best_xml(raw_xml: str) -> None: + try: + parsed, warnings = parse_junit( + raw_xml, branch, list(info.get("tests", [])), branch_ignored + ) + except Exception as exc: + result["test_branch_errors"][branch] = [ + {"error_code": "xml_parse_error", "error_details": str(exc)} + ] + inject_not_run(result, branch, tests, "xml_parse_error") + else: + result["test_results"].extend(parsed) + result["warnings"].extend(warnings) + + while True: + branch_log.append(cleanup_lingering_processes()) + restore_workspace(compiled_snapshot) + extract_trusted_blob(blob, WORKSPACE) + restore_reference_executable() + actual_hash = sha256(WORKSPACE / "executable") + if actual_hash != result["executable_hash"]: + result["test_branch_errors"][branch] = [ + { + "error_code": "executable_hash_mismatch", + "error_details": ( + f"expected {result['executable_hash']}, got {actual_hash}" + ), + } + ] + inject_not_run(result, branch, tests, "executable_hash_mismatch") + break + run_sh = WORKSPACE / "eval" / "run.sh" + if not run_sh.exists(): + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_run_sh", + "error_details": "eval/run.sh missing", + } + ] + inject_not_run(result, branch, tests, "missing_run_sh") + break + # Upstream rewrites thread→signal so xdist workers fail cleanly + # instead of os._exit(1) on timeout. That works in fresh + # containers per branch; here we reuse one container and + # signal timeouts leave TUI/log-watcher subprocesses alive + # (e.g. lazygit --logs + tail -f), wedging pytest for up to + # branch_timeout. Keep the blob's thread method and rely on + # cleanup_lingering_processes + serial fallback after crashes. + env = branch_env( + serial=serial, + has_rerunfailures=has_rerunfailures, + extras=metadata.get("branch_env"), + ) + branch_log.append( + run_step( + "rm -f eval/results.xml results.xml", + WORKSPACE, + timeout=120, + step="clean_stale_results", + accept_failure=True, + ) + ) + if serial: + prepare_serial_run_sh(run_sh) + run_entry = run_step( + run_tests_command(serial=serial), + WORKSPACE, + timeout=branch_timeout, + env=env, + step="run_tests", + accept_failure=True, + ) + branch_log.append(run_entry) + branch_log.append(cleanup_lingering_processes()) + xml_path = find_results_xml() + if xml_path is None: + if best_xml: + merge_best_xml(best_xml) + break + if serial: + result["test_branch_errors"][branch] = [ + { + "error_code": "missing_results_xml", + "error_details": "eval/results.xml was not produced", + } + ] + inject_not_run(result, branch, tests, "missing_results_xml") + break + serial = True + continue + raw_xml = xml_path.read_text(errors="replace") + crashes, n_tests, failures, missing = branch_attempt_metrics( + raw_xml, + run_output=run_entry.get("output", ""), + expected_tests=n_expected, + ) + useful = count_junit_passed(raw_xml) + quality = ( + int(crashes == 0 and missing == 0), + n_tests, + useful, + ) + if quality > best_quality: + best_xml = raw_xml + best_quality = quality + retry = needs_serial_retry( + serial=serial, + crashes=crashes, + missing=missing, + failures=failures, + n_tests=n_tests, + expected_tests=n_expected, + run_output=run_entry.get("output", ""), + ) + if not retry: + merge_best_xml(best_xml) + break + serial = True + for entry in branch_log: + entry["branch"] = branch + result["log"].extend(branch_log) + + return result + + +def write_outputs(result: dict[str, Any], metadata: dict[str, Any]) -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + write_json(LOG_DIR / "programgym_eval.json", result) + write_json(LOG_DIR / "harbor_diagnostics.json", diagnostics(result, metadata)) + rewards = summarize(result, metadata) + write_json(LOG_DIR / "reward.json", rewards) + (LOG_DIR / "reward.txt").write_text(str(rewards["reward"])) + + +def main() -> None: + LOG_DIR.mkdir(parents=True, exist_ok=True) + log_path = LOG_DIR / "programgym_eval.log" + metadata = json.loads(METADATA_PATH.read_text()) + branches = metadata.get("branches", {}) + try: + result = evaluate(metadata) + except Exception as exc: + error_code = type(exc).__name__ + result = { + "test_results": [], + "error_code": error_code, + "error_details": str(exc), + "log": [ + { + "step": "evaluator_exception", + "exception_info": traceback.format_exc(), + "returncode": 1, + } + ], + "solution_branch": "submission", + "test_branches": [ + name for name, info in branches.items() if not info.get("ignored") + ], + "test_branch_errors": { + "__evaluator__": [{"error_code": error_code, "error_details": str(exc)}] + }, + "executable_hash": None, + "warnings": [], + } + for branch, info in branches.items(): + if info.get("ignored"): + continue + inject_not_run(result, branch, branch_tests(info), error_code) + log_path.write_text(traceback.format_exc()) + else: + log_path.write_text("") + write_outputs(result, metadata) + + +if __name__ == "__main__": + main() diff --git a/lbcb-sci--raven.2c3d337/tests/programgym_task.json b/lbcb-sci--raven.2c3d337/tests/programgym_task.json new file mode 100644 index 0000000000000000000000000000000000000000..36408af914685dc0a19d3e6791b6c147fdff1d2f --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/programgym_task.json @@ -0,0 +1,550 @@ +{ + "branches": { + "generated_module_01": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_boundary_conditions.test_bundled_short_fixture_crash_is_stable_across_runs", + "eval.tests.test_boundary_conditions.test_identical_duplicate_reads_trigger_chimeric_boundary", + "eval.tests.test_boundary_conditions.test_insufficient_coverage_crashes_at_chimeric_resolution[flags0]", + "eval.tests.test_boundary_conditions.test_insufficient_coverage_crashes_at_chimeric_resolution[flags1]", + "eval.tests.test_boundary_conditions.test_lone_overlapping_read_pair_still_hits_chimeric_boundary", + "eval.tests.test_boundary_conditions.test_maximizer_frequency_ceiling_drives_chimeric_crash", + "eval.tests.test_boundary_conditions.test_repeat_rich_input_matches_golden_construct_block", + "eval.tests.test_boundary_conditions.test_repeat_rich_input_node_edge_store_counts", + "eval.tests.test_boundary_conditions.test_unitig_size_threshold_boundary", + "eval.tests.test_checkpoint_resume.test_checkpoint_symlink_targets_same_directory_as_cwd", + "eval.tests.test_checkpoint_resume.test_checkpoints_create_cereal_file", + "eval.tests.test_checkpoint_resume.test_disable_checkpoints_creates_no_cereal", + "eval.tests.test_checkpoint_resume.test_disable_checkpoints_short_flag_not_registered", + "eval.tests.test_checkpoint_resume.test_resume_is_observable_via_checkpoint_size", + "eval.tests.test_checkpoint_resume.test_resume_skips_graph_construction", + "eval.tests.test_checkpoint_resume.test_resume_skips_reconstruct_and_reemits_no_duplicate_unitigs", + "eval.tests.test_checkpoint_resume.test_resume_without_cereal_fails", + "eval.tests.test_cli_basics.test_documented_short_config_flags_parse_without_option_error", + "eval.tests.test_cli_basics.test_help_documents_every_overlap_config_option_with_defaults", + "eval.tests.test_cli_basics.test_help_documents_micromizers_and_flag_switches", + "eval.tests.test_cli_basics.test_help_is_byte_identical_to_golden_document", + "eval.tests.test_cli_basics.test_long_flag_requires_a_value_before_positional_file", + "eval.tests.test_cli_basics.test_long_help_print_usage_byte_for_byte", + "eval.tests.test_cli_basics.test_missing_input_file_reports_documented_error", + "eval.tests.test_cli_basics.test_no_arguments_prints_same_usage_as_help_and_exits_zero", + "eval.tests.test_cli_basics.test_polishing_score_flags_are_parsed_and_run_completes", + "eval.tests.test_cli_basics.test_short_help_flag_reports_option_argument_missing", + "eval.tests.test_cli_basics.test_unknown_long_option_prints_getopt_rejection", + "eval.tests.test_cli_basics.test_unregistered_short_flags_hit_getopt_invalid_option[-i-invalid option -- 'i'\\n]", + "eval.tests.test_cli_basics.test_unregistered_short_flags_hit_getopt_invalid_option[-o-invalid option -- 'o'\\n]", + "eval.tests.test_cli_basics.test_unregistered_short_flags_hit_getopt_invalid_option[-r-invalid option -- 'r'\\n]", + "eval.tests.test_cli_basics.test_version_flag_prints_version_number", + "eval.tests.test_construct_pipeline.test_assembly_gfa_and_unitig_gfa_are_distinct_formats", + "eval.tests.test_construct_pipeline.test_combined_overlap_config_produces_valid_graph", + "eval.tests.test_construct_pipeline.test_construct_block_matches_normalized_golden", + "eval.tests.test_construct_pipeline.test_construct_stages_are_executed_in_order", + "eval.tests.test_construct_pipeline.test_default_kmer_produces_deterministic_graph", + "eval.tests.test_construct_pipeline.test_frequency_filter_changes_graph_shape", + "eval.tests.test_construct_pipeline.test_frequency_short_form_flag", + "eval.tests.test_construct_pipeline.test_frequency_threshold_is_honored", + "eval.tests.test_construct_pipeline.test_full_stderr_matches_normalized_golden", + "eval.tests.test_construct_pipeline.test_gfa_is_single_segment_for_linear_fixture", + "eval.tests.test_construct_pipeline.test_graphical_fragment_assembly_long_flag", + "eval.tests.test_construct_pipeline.test_graphical_fragment_assembly_writes_gfa", + "eval.tests.test_construct_pipeline.test_identity_enables_alignment_filtering", + "eval.tests.test_construct_pipeline.test_identity_low_threshold_keeps_graph", + "eval.tests.test_construct_pipeline.test_kmaxnumoverlaps_caps_overlap_count", + "eval.tests.test_construct_pipeline.test_kmer_len_changes_the_constructed_graph", + "eval.tests.test_construct_pipeline.test_kmer_len_short_form_flag_aliases_long_form", + "eval.tests.test_construct_pipeline.test_larger_kmer_len_still_produces_valid_graph", + "eval.tests.test_construct_pipeline.test_min_unitig_size_exact_length_boundary", + "eval.tests.test_construct_pipeline.test_min_unitig_size_monotonic_suppression_sweep", + "eval.tests.test_construct_pipeline.test_min_unitig_size_zero_exposes_the_default_contig", + "eval.tests.test_construct_pipeline.test_missing_gfa_path_writes_no_file", + "eval.tests.test_construct_pipeline.test_negative_polishing_rounds_suppresses_stdout_for_linear_fixture", + "eval.tests.test_construct_pipeline.test_tandem_fixture_assembles_single_utg20_unitig", + "eval.tests.test_construct_pipeline.test_tandem_fixture_node_edge_store_counts", + "eval.tests.test_construct_pipeline.test_tandem_repeat_construct_block_matches_golden", + "eval.tests.test_construct_pipeline.test_thread_count_zero_is_accepted_and_result_invariant", + "eval.tests.test_construct_pipeline.test_threads_option_does_not_change_result", + "eval.tests.test_construct_pipeline.test_unitig_content_matches_length_annotation", + "eval.tests.test_construct_pipeline.test_unitig_gfa_long_flag", + "eval.tests.test_construct_pipeline.test_unitig_gfa_sequence_equals_emitted_stdout_unitig", + "eval.tests.test_construct_pipeline.test_unitig_graphical_fragment_assembly_writes_a_records", + "eval.tests.test_construct_pipeline.test_unitig_high_threshold_exposes_zero_low_exposes_one", + "eval.tests.test_construct_pipeline.test_unitig_output_requires_min_unitig_size_threshold", + "eval.tests.test_construct_pipeline.test_unitig_threshold_is_high_enough_to_suppress_default", + "eval.tests.test_construct_pipeline.test_use_micromizers_completes_pipeline", + "eval.tests.test_construct_pipeline.test_wide_window_alters_edge_set", + "eval.tests.test_construct_pipeline.test_window_len_changes_assembled_sequence", + "eval.tests.test_construct_pipeline.test_window_len_minimum_three_still_assembles", + "eval.tests.test_construct_pipeline.test_window_len_short_form_flag_aliases_long_form", + "eval.tests.test_construct_pipeline.test_zero_frequency_floor_still_assembles", + "eval.tests.test_construct_pipeline.test_zero_polishing_rounds_emits_the_same_unitig", + "eval.tests.test_input_formats.test_assembly_progress_construct_block_is_exact_matching_golden", + "eval.tests.test_input_formats.test_concatenated_split_files_match_single_file_assembly", + "eval.tests.test_input_formats.test_empty_file_before_valid_file_warns_but_still_assembles", + "eval.tests.test_input_formats.test_empty_input_file_prints_warning_then_sequences_error", + "eval.tests.test_input_formats.test_fasta_and_fastq_extensions_both_accepted", + "eval.tests.test_input_formats.test_fastq_carries_quality_header_but_parser_ignores_it", + "eval.tests.test_input_formats.test_fastq_input_assembles_same_linear_unitig", + "eval.tests.test_input_formats.test_gzip_fasta_input_assembles_same_unitig", + "eval.tests.test_input_formats.test_gzip_fastq_input_assembles_same_unitig", + "eval.tests.test_input_formats.test_malformed_nucleotide_reports_exact_non_nucleotide", + "eval.tests.test_input_formats.test_multiple_input_files_are_concatenated", + "eval.tests.test_input_formats.test_nonexistent_input_reports_exact_open_error", + "eval.tests.test_input_formats.test_progress_is_on_stderr_unitigs_on_stdout", + "eval.tests.test_input_formats.test_unsupported_extension_reports_exact_format_list" + ] + }, + "generated_module_02": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_assemble_coverage3.test_graph_gfa_exposes_both_unitig_and_contig_segments", + "reasons": [ + { + "id": "if_no_else", + "message": "pytest test has a conditional assertion with no else branch", + "path": "eval/tests/test_assemble_coverage3.py", + "repair_hint": "Add an else branch that fails, or assert the condition before making conditional checks.", + "severity": "error", + "stage": "static_lint" + } + ] + }, + { + "name": "eval.tests.test_assemble_coverage4.test_resume_from_stage_zero_skips_assemble_early_return", + "reasons": [ + { + "id": "short_substring", + "message": "pytest test uses a too-short substring oracle", + "path": "eval/tests/test_assemble_coverage4.py", + "repair_hint": "Use a longer, specific substring or an exact normalized output comparison.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_assemble_coverage2.test_all_scoring_penalties_combined_reach_layout", + "eval.tests.test_assemble_coverage2.test_gfa_flag_consumes_next_arg_as_path[long]", + "eval.tests.test_assemble_coverage2.test_gfa_flag_consumes_next_arg_as_path[short]", + "eval.tests.test_assemble_coverage2.test_long_gfa_flag_forms_create_layout_files", + "eval.tests.test_assemble_coverage2.test_long_option_forms_parse_and_reach_layout", + "eval.tests.test_assemble_coverage2.test_min_unitig_equal_to_contig_len_drops_unitig", + "eval.tests.test_assemble_coverage2.test_min_unitig_just_below_contig_len_yields_unitig", + "eval.tests.test_assemble_coverage2.test_negative_polish_rounds_still_runs_layout", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[--gap--4]", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[--match-3]", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[--mismatch--5]", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[-g--4]", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[-m-3]", + "eval.tests.test_assemble_coverage2.test_polish_penalty_knobs_accepted_through_layout[-n--5]", + "eval.tests.test_assemble_coverage2.test_unmapped_short_options_are_rejected[-d]", + "eval.tests.test_assemble_coverage2.test_unmapped_short_options_are_rejected[-i]", + "eval.tests.test_assemble_coverage2.test_unmapped_short_options_are_rejected[-o]", + "eval.tests.test_assemble_coverage2.test_unmapped_short_options_are_rejected[-r]", + "eval.tests.test_assemble_coverage3.test_dev_stdin_path_rejected_by_extension_check", + "eval.tests.test_assemble_coverage3.test_graph_gfa_exposes_both_unitig_and_contig_segments", + "eval.tests.test_assemble_coverage3.test_graph_gfa_segment_sequence_length_equals_ln_tag", + "eval.tests.test_assemble_coverage3.test_low_coverage_contig_stays_ctg_under_tiny_min_unitig", + "eval.tests.test_assemble_coverage3.test_sparse_panel_graph_gfa_has_contig_node_only", + "eval.tests.test_assemble_coverage3.test_stdin_dash_path_rejected_by_extension_check", + "eval.tests.test_assemble_coverage4.test_fresh_run_reports_layout_phase_elapsed_time", + "eval.tests.test_assemble_coverage4.test_gfa_flag_to_missing_directory_is_silently_masked", + "eval.tests.test_assemble_coverage4.test_min_unitig_zero_on_80_panel_keeps_low_coverage_contig_gated", + "eval.tests.test_assemble_coverage4.test_min_unitig_zero_on_sparse_panel_yields_no_contig", + "eval.tests.test_assemble_coverage4.test_negative_min_unitig_wraps_and_qualifies_nothing", + "eval.tests.test_assemble_coverage4.test_resume_from_stage_zero_skips_assemble_early_return", + "eval.tests.test_assemble_coverage5.test_combined_panel_checkpoint_resume_reproduces_utg18", + "eval.tests.test_assemble_coverage5.test_combined_panel_construct_stores_expected_nodes_edges", + "eval.tests.test_assemble_coverage5.test_combined_panel_graph_gfa_matches_golden", + "eval.tests.test_assemble_coverage5.test_combined_panel_graph_gfa_s_record_invariants", + "eval.tests.test_assemble_coverage5.test_combined_panel_min_unitig_exact_boundary_22922", + "eval.tests.test_assemble_coverage5.test_combined_panel_reports_120_loaded_sequences", + "eval.tests.test_assemble_coverage5.test_combined_panel_stdout_matches_golden", + "eval.tests.test_assemble_graph.test_assemble_runs_transitive_then_tips_bubbles_then_long_edges", + "eval.tests.test_assemble_graph.test_assemble_stages_all_report[40reads]", + "eval.tests.test_assemble_graph.test_assemble_stages_all_report[80reads]", + "eval.tests.test_assemble_graph.test_assembly_is_deterministic_across_runs", + "eval.tests.test_assemble_graph.test_canonical_contig_header_and_len", + "eval.tests.test_assemble_graph.test_checkpoints_create_binary_archive", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[--identity-0.9]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[--kMaxNumOverlaps-16]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[--kmer-len-21]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[-M-None]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[-f-0.001]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[-k-15]", + "eval.tests.test_assemble_graph.test_construct_knobs_are_accepted_through_layout[-w-5]", + "eval.tests.test_assemble_graph.test_construct_stores_real_edges_before_layout", + "eval.tests.test_assemble_graph.test_degenerate_read_set_produces_no_contigs_but_runs_layout", + "eval.tests.test_assemble_graph.test_disable_checkpoints_creates_no_archive", + "eval.tests.test_assemble_graph.test_gfa_flag_creates_layout_file", + "eval.tests.test_assemble_graph.test_gfa_structure_is_stable_for_80reads", + "eval.tests.test_assemble_graph.test_graph_and_unitig_gfa_are_distinct_files", + "eval.tests.test_assemble_graph.test_identity_threshold_changes_constructed_graph_edges", + "eval.tests.test_assemble_graph.test_min_unitig_size_alters_observed_unitig_threshold", + "eval.tests.test_assemble_graph.test_min_unitig_size_is_accepted_and_changes_output_set[10000]", + "eval.tests.test_assemble_graph.test_min_unitig_size_is_accepted_and_changes_output_set[100]", + "eval.tests.test_assemble_graph.test_min_unitig_size_is_accepted_and_changes_output_set[25000]", + "eval.tests.test_assemble_graph.test_resume_loads_checkpoint_and_skips_reconstruction[plain]", + "eval.tests.test_assemble_graph.test_resume_loads_checkpoint_and_skips_reconstruction[with_gfa]", + "eval.tests.test_assemble_graph.test_resume_without_checkpoint_fails_cleanly", + "eval.tests.test_assemble_graph.test_stdout_fasta_exactly_matches_golden", + "eval.tests.test_assemble_graph.test_successful_assembly_produces_contigs", + "eval.tests.test_assemble_graph.test_thread_count_variants_run_layout[1]", + "eval.tests.test_assemble_graph.test_thread_count_variants_run_layout[2]", + "eval.tests.test_assemble_graph.test_thread_count_variants_run_layout[8]", + "eval.tests.test_assemble_graph.test_unitig_gfa_flag_writes_unitig_layout", + "eval.tests.test_cli_basics.test_help_covers_layout_phase_flags", + "eval.tests.test_cli_basics.test_long_help_prints_usage_and_exits_zero", + "eval.tests.test_cli_basics.test_no_arguments_prints_usage_and_exits_zero", + "eval.tests.test_cli_basics.test_option_requiring_value_with_missing_value", + "eval.tests.test_cli_basics.test_options_alone_after_parse_missing_input", + "eval.tests.test_cli_basics.test_short_help_flag_is_treated_as_option_needing_arg", + "eval.tests.test_cli_basics.test_unknown_long_option_rejected", + "eval.tests.test_cli_basics.test_unknown_short_option_rejected", + "eval.tests.test_cli_basics.test_version_flag_prints_version_and_exits_zero", + "eval.tests.test_graph_structure.test_contig_sequence_is_valid_dna", + "eval.tests.test_graph_structure.test_gfa_node_names_agree_with_stdout_contigs", + "eval.tests.test_graph_structure.test_graph_gfa_edge_orientation_field", + "eval.tests.test_graph_structure.test_micromizer_and_default_construction_both_reach_layout", + "eval.tests.test_graph_structure.test_micromizer_flag_runs_layout_and_produces_contigs", + "eval.tests.test_graph_structure.test_more_reads_build_a_larger_pre_layout_graph", + "eval.tests.test_graph_structure.test_unitig_gfa_annotations_link_to_read_names", + "eval.tests.test_graph_structure.test_unitig_gfa_s_records_carry_color_field", + "eval.tests.test_input_io.test_empty_fasta_reports_empty_and_fails", + "eval.tests.test_input_io.test_empty_fastq_reports_empty_and_fails", + "eval.tests.test_input_io.test_gzip_fasta_is_accepted_and_assembles", + "eval.tests.test_input_io.test_gzip_fastq_is_accepted", + "eval.tests.test_input_io.test_mixed_valid_and_missing_input_fails", + "eval.tests.test_input_io.test_multiple_input_files_are_combined", + "eval.tests.test_input_io.test_nonexistent_input_file_fails_open[.fa]", + "eval.tests.test_input_io.test_nonexistent_input_file_fails_open[.fasta]", + "eval.tests.test_input_io.test_nonexistent_input_file_fails_open[.fastq]", + "eval.tests.test_input_io.test_nonexistent_input_file_fails_open[.fq]", + "eval.tests.test_input_io.test_nothing_but_header_fasta_is_invalid", + "eval.tests.test_input_io.test_plain_and_gzip_payload_produce_same_contigs", + "eval.tests.test_input_io.test_single_record_fasta_is_parsed", + "eval.tests.test_input_io.test_unsupported_extension_rejected[.txt]", + "eval.tests.test_input_io.test_unsupported_extension_rejected[.xyz]", + "eval.tests.test_input_io.test_unsupported_extension_rejected[noext]" + ] + }, + "generated_module_03": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [], + "tests": [ + "eval.tests.test_assembly_basic.test_both_fasta_and_fastq_inputs_emerge_same_unitig", + "eval.tests.test_assembly_basic.test_construct_stage_chain_reports_each_pile_phase", + "eval.tests.test_assembly_basic.test_default_pipeline_polished_unitig_is_byte_identical_to_golden", + "eval.tests.test_assembly_basic.test_fasta_output_is_unambiguous_canonical_bases", + "eval.tests.test_assembly_basic.test_low_prefix_subset_produces_no_unitig_via_pile_filter", + "eval.tests.test_assembly_basic.test_micromizer_construction_flag_runs_pipeline", + "eval.tests.test_assembly_basic.test_min_unitig_size_filter_outputs_nothing_when_too_large", + "eval.tests.test_assembly_basic.test_output_is_deterministic_across_runs_and_matches_golden", + "eval.tests.test_assembly_basic.test_relaxed_min_unitig_size_still_emits_the_unitig", + "eval.tests.test_assembly_basic.test_threading_does_not_change_result", + "eval.tests.test_assembly_basic.test_unitig_header_carries_ln_rc_xo_tags", + "eval.tests.test_cli.test_help_documents_polish_and_pile_knobs", + "eval.tests.test_cli.test_help_long_flag_output_matches_exact_golden", + "eval.tests.test_cli.test_help_short_flag_rejected_while_long_help_works", + "eval.tests.test_cli.test_missing_input_file_error", + "eval.tests.test_cli.test_no_arguments_prints_same_usage_and_succeeds", + "eval.tests.test_cli.test_nonexistent_input_file_reports_unable_to_open", + "eval.tests.test_cli.test_short_forms_absent_from_optstring_are_rejected", + "eval.tests.test_cli.test_thread_count_does_not_change_emit_decision", + "eval.tests.test_cli.test_threads_flag_accepts_and_reports_timing", + "eval.tests.test_cli.test_unknown_long_option_fails_with_getopt_diag", + "eval.tests.test_cli.test_unknown_short_option_fails_with_invalid_option_diag", + "eval.tests.test_cli.test_version_long_flag_print_semver", + "eval.tests.test_gfa_output.test_assembly_graph_gfa_matches_exact_golden", + "eval.tests.test_gfa_output.test_graph_and_unitig_gfa_files_generated", + "eval.tests.test_gfa_output.test_graph_gfa_segment_length_tag_matches_polished_contig", + "eval.tests.test_gfa_output.test_unitig_gfa_contains_adjacency_records", + "eval.tests.test_input_errors.test_all_inputs_empty_errors", + "eval.tests.test_input_errors.test_concatenated_batch_of_files_participates_in_pile", + "eval.tests.test_input_errors.test_empty_file_warns_and_errors", + "eval.tests.test_input_errors.test_fasta_input_produces_single_annotated_unitig", + "eval.tests.test_input_errors.test_gzip_compressed_fastq_input_assembles", + "eval.tests.test_input_errors.test_gzip_empty_file_warns_and_errors", + "eval.tests.test_input_errors.test_gzip_input_polish_is_identical_to_plain_input", + "eval.tests.test_input_errors.test_header_only_fasta_reports_invalid_format", + "eval.tests.test_input_errors.test_low_read_volume_yields_no_false_assembly", + "eval.tests.test_pile_reachability.test_degenerate_alignment_scoring_still_completes", + "eval.tests.test_pile_reachability.test_different_read_batches_yield_different_pile_outcomes", + "eval.tests.test_pile_reachability.test_gzip_and_plain_fastq_concatenate_into_one_pile_set", + "eval.tests.test_pile_reachability.test_identity_filter_on_full_set_reaches_edlib_path", + "eval.tests.test_pile_reachability.test_identity_filter_with_micromizers_reaches_overlap_edlib", + "eval.tests.test_pile_reachability.test_micromizer_seeding_preserves_unitig_id", + "eval.tests.test_pile_reachability.test_min_unitig_size_boundary_flips_emit_decision", + "eval.tests.test_pile_stress.test_aggressive_frequency_collapses_pile_to_no_unitig", + "eval.tests.test_pile_stress.test_cross_knob_matrix_each_yields_single_lambda_unitig", + "eval.tests.test_pile_stress.test_frequency_005_selects_fresh_unitig", + "eval.tests.test_pile_stress.test_frequency_gradient_steps_through_pile_thresholds", + "eval.tests.test_pile_stress.test_frequency_threshold_changes_pile_outcome", + "eval.tests.test_pile_stress.test_high_identity_filter_removes_all_overlaps", + "eval.tests.test_pile_stress.test_high_kmer_length_collapses_pile_to_no_unitig", + "eval.tests.test_pile_stress.test_identity_07_selects_distinct_unitig", + "eval.tests.test_pile_stress.test_identity_below_threshold_leaves_consensus_unchanged", + "eval.tests.test_pile_stress.test_identity_filter_enables_overlap_edlib_phase", + "eval.tests.test_pile_stress.test_identity_threshold_long_flag_accepted", + "eval.tests.test_pile_stress.test_identity_threshold_short_flag_is_rejected", + "eval.tests.test_pile_stress.test_kmer_length_13_selects_longer_unitig", + "eval.tests.test_pile_stress.test_kmer_length_17_selects_distinct_region", + "eval.tests.test_pile_stress.test_kmer_length_19_selects_distinct_unitig", + "eval.tests.test_pile_stress.test_kmer_length_variants_reach_pile_pipeline", + "eval.tests.test_pile_stress.test_larger_input_produces_longer_contig_matching_golden", + "eval.tests.test_pile_stress.test_overlap_limit_long_flag_accepted_and_bounds_piles", + "eval.tests.test_pile_stress.test_overlap_limit_short_flag_is_rejected", + "eval.tests.test_pile_stress.test_window_length_10_changes_consensus_length", + "eval.tests.test_pile_stress.test_window_length_11_picks_more_support", + "eval.tests.test_pile_stress.test_window_length_7_changes_consensus_length", + "eval.tests.test_pile_stress.test_window_length_variants_accepted_and_reach_piles", + "eval.tests.test_polish_behavior.test_alignment_scoring_affects_consensus", + "eval.tests.test_polish_behavior.test_checkpoint_count_scales_with_rounds", + "eval.tests.test_polish_behavior.test_checkpoint_created_without_disable_flag", + "eval.tests.test_polish_behavior.test_disable_checkpoints_skips_archive", + "eval.tests.test_polish_behavior.test_empty_unitig_set_returns_before_polish", + "eval.tests.test_polish_behavior.test_negative_gap_penalty_accepted", + "eval.tests.test_polish_behavior.test_polish_rounds_progress_reported_on_stderr", + "eval.tests.test_polish_behavior.test_polishing_changes_unpolished_unitig", + "eval.tests.test_polish_behavior.test_positive_gap_penalty_rejected_by_polisher", + "eval.tests.test_polish_behavior.test_resume_from_checkpoint_reloads_and_repolishes", + "eval.tests.test_polish_behavior.test_resume_without_checkpoint_fails_cleanly", + "eval.tests.test_polish_behavior.test_small_set_no_unitig_skips_polish", + "eval.tests.test_polish_behavior.test_two_rounds_identical_contig_id_and_length", + "eval.tests.test_polish_behavior.test_zero_rounds_output_is_byte_identical_to_unpolished_golden", + "eval.tests.test_polish_behavior.test_zero_rounds_skips_polish_completely", + "eval.tests.test_polish_distinct_coverage.test_alternative_alignment_scoring_matches_exact_golden", + "eval.tests.test_polish_distinct_coverage.test_combined_seeding_knobs_match_exact_golden", + "eval.tests.test_polish_distinct_coverage.test_fasta_input_polished_output_matches_exact_golden", + "eval.tests.test_polish_distinct_coverage.test_three_polish_rounds_match_exact_golden", + "eval.tests.test_polish_distinct_coverage.test_two_polish_rounds_match_exact_golden", + "eval.tests.test_polish_distinct_coverage.test_zero_gap_penalty_accepted_matches_exact_golden" + ] + }, + "generated_module_04": { + "ignore_reason": "", + "ignored": false, + "ignored_tests": [ + { + "name": "eval.tests.test_cli.test_help_exposes_default_thread_count", + "reasons": [ + { + "id": "golden_docstring", + "message": "pytest test docstring mentions golden data that is not used in the body", + "path": "eval/tests/test_cli.py", + "repair_hint": "Use the golden fixture mentioned in the docstring or remove the misleading claim.", + "severity": "error", + "stage": "static_lint" + }, + { + "id": "golden_no_equality", + "message": "pytest test references golden data without equality comparison", + "path": "eval/tests/test_cli.py", + "repair_hint": "Compare observed output to golden data with equality after any explicit normalization.", + "severity": "error", + "stage": "static_lint" + } + ] + } + ], + "tests": [ + "eval.tests.test_assembly.test_contig_header_carries_read_count_tag", + "eval.tests.test_assembly.test_contig_header_length_tag_matches_sequence_length", + "eval.tests.test_assembly.test_contig_sequence_is_iupac_bases", + "eval.tests.test_assembly.test_contig_stdout_line_count_is_even_and_positive", + "eval.tests.test_assembly.test_full_run_emits_contig_fasta_to_stdout", + "eval.tests.test_assembly.test_identity_threshold_long_option_succeeds[0.02]", + "eval.tests.test_assembly.test_identity_threshold_long_option_succeeds[0.05]", + "eval.tests.test_assembly.test_identity_threshold_long_option_succeeds[0.10]", + "eval.tests.test_assembly.test_kmer_len_option_changes_output_shape", + "eval.tests.test_assembly.test_kmer_longer_than_reads_still_assembles", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--gap--4]", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--kmer-len-15]", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--match-3]", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--mismatch--5]", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--polishing-rounds-0]", + "eval.tests.test_assembly.test_long_form_option_aliases_are_accepted[--window-len-5]", + "eval.tests.test_assembly.test_max_num_overlaps_long_option_succeeds[32]", + "eval.tests.test_assembly.test_max_num_overlaps_long_option_succeeds[4]", + "eval.tests.test_assembly.test_max_num_overlaps_long_option_succeeds[8]", + "eval.tests.test_assembly.test_micro_mizer_mode_emits_contigs", + "eval.tests.test_assembly.test_min_unitig_size_above_longest_contig_filters_everything", + "eval.tests.test_assembly.test_min_unitig_size_smaller_than_contig_length", + "eval.tests.test_assembly.test_negative_min_unitig_size_wraps_and_filters_all", + "eval.tests.test_assembly.test_polishing_rounds_variants_succeed", + "eval.tests.test_assembly.test_positive_gap_penalty_is_accepted", + "eval.tests.test_assembly.test_run_emits_timing_summary_to_stderr", + "eval.tests.test_assembly.test_scoring_and_frequency_options_succeed[-f-0.001]", + "eval.tests.test_assembly.test_scoring_and_frequency_options_succeed[-g--4]", + "eval.tests.test_assembly.test_scoring_and_frequency_options_succeed[-m-3]", + "eval.tests.test_assembly.test_scoring_and_frequency_options_succeed[-n--5]", + "eval.tests.test_assembly.test_two_polishing_rounds_emit_contigs", + "eval.tests.test_assembly.test_window_len_option_succeeds", + "eval.tests.test_assembly.test_window_len_value_changes_unitig_count", + "eval.tests.test_assembly.test_zero_min_unitig_size_reports_all_contigs", + "eval.tests.test_assembly.test_zero_thread_count_still_assembles", + "eval.tests.test_checkpoints.test_checkpoint_file_is_a_binary_cereal_archive", + "eval.tests.test_checkpoints.test_checkpoint_file_is_created_when_checkpoints_enabled", + "eval.tests.test_checkpoints.test_checkpoint_is_written_into_the_process_cwd", + "eval.tests.test_checkpoints.test_disable_checkpoints_prevents_checkpoint_file", + "eval.tests.test_checkpoints.test_resume_after_default_polish_skips_file_reload", + "eval.tests.test_checkpoints.test_resume_loads_a_prior_checkpoint", + "eval.tests.test_checkpoints.test_resume_output_is_deterministic_across_runs", + "eval.tests.test_checkpoints.test_resume_then_emit_graph_and_unitig_gfa", + "eval.tests.test_checkpoints.test_resume_then_run_overwrites_checkpoint_file", + "eval.tests.test_checkpoints.test_resume_with_checkpoints_disabled_leaves_checkpoint_unchanged", + "eval.tests.test_checkpoints.test_resume_with_corrupted_checkpoint_fails_with_load_error", + "eval.tests.test_checkpoints.test_resume_with_fewer_polishing_rounds_skips_reload", + "eval.tests.test_checkpoints.test_resume_with_more_polishing_rounds_reloads_sequences", + "eval.tests.test_checkpoints.test_resume_without_existing_checkpoint_fails_cleanly", + "eval.tests.test_checkpoints.test_resumed_run_still_emits_contigs_to_stdout", + "eval.tests.test_cli.test_help_documents_input_compression", + "eval.tests.test_cli.test_help_exposes_default_kmer_len", + "eval.tests.test_cli.test_help_exposes_default_thread_count", + "eval.tests.test_cli.test_help_goes_to_stdout_not_stderr", + "eval.tests.test_cli.test_help_lists_every_long_option_token", + "eval.tests.test_cli.test_help_usage_line_is_emitted_to_stdout", + "eval.tests.test_cli.test_micromizer_flag_alone_still_requires_input", + "eval.tests.test_cli.test_missing_input_file_reports_error_and_exits_failure", + "eval.tests.test_cli.test_negative_scoring_option_requires_a_valid_range_but_parses", + "eval.tests.test_cli.test_no_arguments_does_not_report_missing_input", + "eval.tests.test_cli.test_no_arguments_output_matches_help_golden_exactly", + "eval.tests.test_cli.test_no_arguments_prints_usage_and_exits_zero", + "eval.tests.test_cli.test_options_after_positional_input_are_still_parsed", + "eval.tests.test_cli.test_short_F_without_argument_is_rejected", + "eval.tests.test_cli.test_short_h_requires_an_argument_in_this_build", + "eval.tests.test_cli.test_short_v_is_an_unrecognized_option", + "eval.tests.test_cli.test_undocumented_short_options_are_rejected[argv0]", + "eval.tests.test_cli.test_undocumented_short_options_are_rejected[argv1]", + "eval.tests.test_cli.test_undocumented_short_options_are_rejected[argv2]", + "eval.tests.test_cli.test_undocumented_short_options_are_rejected[argv3]", + "eval.tests.test_cli.test_unknown_long_option_is_rejected_with_option_name", + "eval.tests.test_cli.test_version_long_flag_prints_version_to_stdout", + "eval.tests.test_cli.test_version_prints_nothing_to_stderr", + "eval.tests.test_cli.test_version_shortcircuits_before_input_processing", + "eval.tests.test_graph_output.test_graph_gfa_and_unitig_gfa_both_exist_and_differ", + "eval.tests.test_graph_output.test_graph_gfa_count_tag_is_positive", + "eval.tests.test_graph_output.test_graph_gfa_depth_tag_has_float_value", + "eval.tests.test_graph_output.test_graph_gfa_edge_records_are_well_formed", + "eval.tests.test_graph_output.test_graph_gfa_emits_at_least_one_valid_segment", + "eval.tests.test_graph_output.test_graph_gfa_length_tag_matches_sequence_length", + "eval.tests.test_graph_output.test_graph_gfa_segment_carries_length_coverage_and_depth_tags", + "eval.tests.test_graph_output.test_graph_gfa_segment_records_have_six_tab_delimited_columns", + "eval.tests.test_graph_output.test_graph_gfa_sequence_field_contains_only_iupac_bases", + "eval.tests.test_graph_output.test_graph_gfa_uses_only_segment_and_link_records[L]", + "eval.tests.test_graph_output.test_graph_gfa_uses_only_segment_and_link_records[S]", + "eval.tests.test_graph_output.test_graphical_flag_to_unwritable_path_creates_no_file", + "eval.tests.test_graph_output.test_graphical_flag_with_empty_path_creates_no_file", + "eval.tests.test_graph_output.test_graphical_flag_writes_file_at_requested_path", + "eval.tests.test_graph_output.test_regular_and_unitig_gfa_diverge_in_tags", + "eval.tests.test_graph_output.test_unitig_flag_alone_writes_unitig_but_no_graph_gfa", + "eval.tests.test_graph_output.test_unitig_flag_with_empty_path_creates_no_file", + "eval.tests.test_graph_output.test_unitig_flag_writes_file_at_requested_path", + "eval.tests.test_graph_output.test_unitig_gfa_alignment_lines_outnumber_or_equal_segments", + "eval.tests.test_graph_output.test_unitig_gfa_emits_alignment_records_mapping_reads", + "eval.tests.test_graph_output.test_unitig_gfa_segments_carry_color_tag", + "eval.tests.test_graph_output.test_unitig_gfa_segments_have_six_columns", + "eval.tests.test_graph_output.test_unitig_gfa_unitig_length_tag_is_positive", + "eval.tests.test_io_parsing.test_all_empty_inputs_report_each_file_and_fail", + "eval.tests.test_io_parsing.test_all_plain_extensions_report_the_same_load_count[.fa.gz]", + "eval.tests.test_io_parsing.test_all_plain_extensions_report_the_same_load_count[.fa]", + "eval.tests.test_io_parsing.test_all_plain_extensions_report_the_same_load_count[.fasta.gz]", + "eval.tests.test_io_parsing.test_all_plain_extensions_report_the_same_load_count[.fasta]", + "eval.tests.test_io_parsing.test_empty_fasta_warns_and_exits_failure", + "eval.tests.test_io_parsing.test_fa_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fa_gzip_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fasta_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fasta_gzip_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fastq_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fastq_gzip_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fq_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_fq_gzip_extension_loads_74_sequences", + "eval.tests.test_io_parsing.test_malformed_fasta_is_rejected_with_parser_error", + "eval.tests.test_io_parsing.test_malformed_fastq_is_rejected_with_parser_error", + "eval.tests.test_io_parsing.test_missing_input_file_fails_with_bio_parser_open_error", + "eval.tests.test_io_parsing.test_mixed_empty_and_valid_inputs_use_the_valid_set", + "eval.tests.test_io_parsing.test_mixed_fasta_and_fastq_inputs_are_combined", + "eval.tests.test_io_parsing.test_multiple_input_files_are_combined_into_one_set", + "eval.tests.test_io_parsing.test_same_input_file_given_twice_loads_double_count", + "eval.tests.test_io_parsing.test_unsupported_extension_error_names_the_file", + "eval.tests.test_io_parsing.test_unsupported_extension_reports_error_with_valid_list", + "eval.tests.test_io_parsing.test_unsupported_uppercase_extension_is_rejected" + ] + } + }, + "commit": "2c3d33740d04989062170ee6e241fb640071621c", + "data_source": "synthetic_programgym", + "difficulty": "easy", + "difficulty_score": 1.6908160579809155, + "eval_clean_hashes": [ + "1f5febe9c0a0c981320f22a9c1d5bf66cec7639c6f915e3877050479e8d183b3" + ], + "input_record": { + "commit": "2c3d33740d04989062170ee6e241fb640071621c", + "difficulty": "easy", + "difficulty_code_lines": 4907, + "difficulty_has_tests": false, + "difficulty_product_code_lines": 4907, + "difficulty_runtime_deps": 0, + "difficulty_score": 1.6908160579809155, + "difficulty_test_code_lines": 97, + "full_name": "lbcb-sci/raven", + "input_joern_zip": "cpp_joern/lbcb-sci__raven.zip", + "joern_status": true, + "joern_time": 11.63805147097446, + "language": "cpp", + "pb_match": [ + { + "pb_fullname": "gromacs/gromacs", + "rank": 779, + "similarity": 0.46602803468704224 + } + ], + "repo_path": "cpp/lbcb-sci__raven", + "source": "commit:2c3d33740d04989062170ee6e241fb640071621c", + "status": "done", + "url": "https://github.com/lbcb-sci/raven" + }, + "instance_id": "lbcb-sci__raven.2c3d337", + "language": "cpp", + "module_iterations": [ + { + "actual_iterations": 5, + "branch_name": "generated_module_01", + "iteration_limit": 5, + "module_index": 1, + "module_kind": "source", + "termination_reason": "max_iterations" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_02", + "iteration_limit": 5, + "module_index": 2, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_03", + "iteration_limit": 5, + "module_index": 3, + "module_kind": "source", + "termination_reason": "early_stopping" + }, + { + "actual_iterations": 5, + "branch_name": "generated_module_04", + "iteration_limit": 5, + "module_index": 4, + "module_kind": "source", + "termination_reason": "max_iterations" + } + ], + "repository": "lbcb-sci/raven" +} diff --git a/lbcb-sci--raven.2c3d337/tests/test.sh b/lbcb-sci--raven.2c3d337/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c97cf1219034b84854bf1102d30b4347149dbe --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/test.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Verifier exec may not inherit image ENV (Modal/gVisor, login-shell resets). +export PATH="/usr/local/go/bin:/go/bin:/usr/local/cargo/bin:/root/.cargo/bin:${PATH}" + +mkdir -p /logs/verifier /logs/artifacts + +write_failure() { + local code="$1" + local details="$2" + python3 - "$code" "$details" <<'PY' +import json +import sys +from pathlib import Path + +code, details = sys.argv[1:3] +try: + metadata = json.loads(Path("/tests/programgym_task.json").read_text()) + n_tests = sum( + len([ + name for name in info.get("tests", []) + if name not in {item.get("name") for item in info.get("ignored_tests", [])} + ]) + for branch, info in metadata.get("branches", {}).items() + if not info.get("ignored") + ) +except Exception: + n_tests = 0 +result = { + "test_results": [], + "error_code": code, + "error_details": details, + "log": [], + "solution_branch": "submission", + "test_branches": [], + "test_branch_errors": { + "__infra__": [{"error_code": code, "error_details": details}] + }, + "executable_hash": None, + "warnings": [], +} +diagnostics = { + "pass_rate": 0.0, + "resolved": 0, + "n_passed": 0, + "n_tests": n_tests, + "n_branch_errors": 1, + "infra_error": 1, + "executable_hash_present": 0, +} +Path("/logs/verifier/programgym_eval.json").write_text( + json.dumps(result, indent=2, sort_keys=True) +) +Path("/logs/verifier/harbor_diagnostics.json").write_text( + json.dumps(diagnostics, indent=2, sort_keys=True) +) +Path("/logs/verifier/reward.json").write_text( + json.dumps( + {"reward": 0.0, "resolved": 0.0, "almost_resolved": 0.0}, + indent=2, + sort_keys=True, + ) +) +Path("/logs/verifier/reward.txt").write_text("0.0") +Path("/logs/verifier/programgym_eval.log").write_text(details) +PY +} + +if ! command -v python3 >/dev/null 2>&1; then + write_failure "missing_python3" "python3 is required in the cleanroom image" + exit 0 +fi + +if ! python3 /tests/programgym_evaluator.py; then + if [ ! -s /logs/verifier/reward.txt ]; then + write_failure "evaluator_crashed" \ + "programgym_evaluator.py exited non-zero with no reward written" + fi +fi + +exit 0 diff --git a/lbcb-sci--raven.2c3d337/tests/workspace.tar.gz b/lbcb-sci--raven.2c3d337/tests/workspace.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3d38b2e4cccdcabbe985435af0c688b9ad93a83c --- /dev/null +++ b/lbcb-sci--raven.2c3d337/tests/workspace.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d33ac48375c20e801aa1ad9dda93c91f3f7c6c4b797f7f761e2cb58efa21b27 +size 2586 diff --git a/leaanthony--clir.a8d9462/environment/Dockerfile b/leaanthony--clir.a8d9462/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6f371332b0892136e00733449b81644d11444adf --- /dev/null +++ b/leaanthony--clir.a8d9462/environment/Dockerfile @@ -0,0 +1,58 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND=noninteractive +ENV RUSTUP_DIST_SERVER="https://static.rust-lang.org" +ENV RUSTUP_UPDATE_ROOT="https://static.rust-lang.org/rustup" +ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse +ENV CARGO_REGISTRIES_CRATES_IO_INDEX="sparse+https://index.crates.io/" +ENV CARGO_NET_GIT_FETCH_WITH_CLI=true +ENV GOPROXY="https://proxy.golang.org,direct" +ENV GOSUMDB=sum.golang.google.cn +ENV GOTOOLCHAIN=auto +ENV UV_INSECURE_HOST="" +ENV UV_INDEX_URL="https://pypi.org/simple" +ENV UV_EXTRA_INDEX_URL=https://pypi.org/simple +ENV UV_CACHE_DIR=/workspace/.cache/uv +ENV npm_config_registry="https://registry.npmjs.org/" +ENV npm_config_strict_ssl=false +ENV npm_config_cache=/workspace/.cache/npm +ENV PIP_INDEX_URL="https://pypi.org/simple" +ENV PIP_EXTRA_INDEX_URL=https://pypi.org/simple +ENV PIP_TRUSTED_HOST="" +ENV HOME=/workspace +ENV XDG_CACHE_HOME=/workspace/.cache +ENV PIP_CACHE_DIR=/workspace/.cache/pip +ENV PYTHONUSERBASE=/workspace/.local +ENV GOROOT=/usr/local/go +ENV GOPATH=/workspace/.go +ENV GOCACHE=/workspace/.cache/go-build +ENV PIP_BREAK_SYSTEM_PACKAGES=1 +ENV PATH=/opt/programgym-venv/bin:/usr/local/go/bin:/workspace/.go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +ENV PAGER=cat +ENV MANPAGER=cat +ENV LESS=-R +ENV TQDM_DISABLE=1 +ENV VIRTUAL_ENV=/opt/programgym-venv +RUN apt-get update && apt-get install -y --no-install-recommends bash build-essential ca-certificates git make pkg-config python3 python3-pip curl wget xz-utils unzip zip bzip2 zstd patch file binutils python3-venv tar && rm -rf /var/lib/apt/lists/* +COPY programgym-go.tar.gz /tmp/programgym-go.tar.gz +RUN set -eux; rm -rf /usr/local/go; tar -C /usr/local -xzf /tmp/programgym-go.tar.gz; rm -f /tmp/programgym-go.tar.gz; if [ ! -x /usr/local/go/bin/go ]; then echo "official Go tarball did not create /usr/local/go/bin/go" >&2; exit 1; fi; /usr/local/go/bin/go version +RUN python3 -m venv /opt/programgym-venv && /opt/programgym-venv/bin/python -m pip install --no-cache-dir --only-binary=:all: pytest pytest-xdist coverage +WORKDIR /workspace +ADD workspace.tar.gz /workspace/ +COPY executable /workspace/executable +COPY download.sh /workspace/download.sh +RUN chmod 755 /workspace/download.sh +RUN ["bash","-lc","set -euo pipefail; cd /workspace; set -a; source /workspace/download.sh; set +a; python3 - <<'PY' > /etc/profile.d/programgym_download_env.sh\nimport os\nimport re\nimport shlex\nignored = {\"OLDPWD\", \"PWD\", \"SHLVL\", \"_\"}\nvalid_name = re.compile(r\"^[A-Za-z_][A-Za-z0-9_]*$\")\nfor key in sorted(os.environ):\n if key in ignored or key.startswith(\"BASH_FUNC_\") or not valid_name.fullmatch(key):\n continue\n value = os.environ[key]\n if \"\\n\" in value:\n continue\n print(f\"export {key}={shlex.quote(value)}\")\nPY\n"] +ENV BASH_ENV=/etc/profile.d/programgym_download_env.sh +RUN chmod 111 /workspace/executable +WORKDIR /workspace +# Harbor synthetic ProgramGym adapter: run the agent as an unprivileged user. +# Keep tool/runtime state under /home/agent and reserve /workspace for the +# submission handed to the separate verifier. Keep the reference executable +# execute-only; the oracle temporarily restores owner read permission. +RUN id -u agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent +RUN mkdir -p /home/agent \ + && chown -R agent:agent /home/agent /workspace \ + && chown agent:agent /workspace/executable \ + && chmod 111 /workspace/executable +ENV HOME=/home/agent +WORKDIR /workspace diff --git a/leaanthony--clir.a8d9462/environment/download.sh b/leaanthony--clir.a8d9462/environment/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..7c80232b6dfe238543a0181e3f7eb89ec28cada5 --- /dev/null +++ b/leaanthony--clir.a8d9462/environment/download.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +# PROGRAMGYM-DEFAULT-GO-DOWNLOAD: v1 +# No Go module dependencies to prefetch; the agent may replace this only for required OS/tool dependencies. +: