# Test exclusions for the locally rebuilt x86-64-v3 package set.
#
# Selecting x86-64-v3 changes every affected derivation, so the normal
# nixpkgs binary cache cannot be used and upstream test suites run locally.
# The jeeves builder uses /tmp/nix-builds so filesystem tests run on tmpfs
# instead of ZFS with normalization=formD and utf8only=on; those tests remain
# enabled. The remaining workarounds cover UDP readiness, resource-sensitive
# parser and nested-worker races, and mismatched timeout clocks, plus
# architecture-dependent floating-point differences whose risk we accept for
# our workloads. Keep these exceptions visible until their causes are fixed.
_final: prev: {
  gnutls = prev.gnutls.overrideAttrs (old: {
    # This test uses a fixed four-second sleep instead of checking UDP
    # readiness; the client saw no listener in the x86-64-v3 build.
    postPatch = (old.postPatch or "") + ''
      sed '2iexit 77' -i tests/serv-udp.sh
    '';
  });

  onnxruntime = prev.onnxruntime.overrideAttrs (old: {
    # OpenVINO uses a different QuantizeLinear formulation. x86-64-v3 moves
    # these INT8 results by one quantization unit; we accept that inference-
    # precision risk for our workloads.
    env = (old.env or { }) // {
      GTEST_FILTER = "*:-QuantizeLinearOpTest.Int8:QuantizeLinearOpTest.OVEP_Int8_NegativeZeroPoint:QuantizeLinearOpTest.OVEP_Int8_PositiveZeroPoint";
    };
  });

  prometheus = prev.prometheus.overrideAttrs (
    old:
    let
      assets = old.passthru.assets.overrideAttrs (assetsOld: {
        # CodeMirror's bounded synchronous parser can return an incomplete tree
        # when these cases run on a heavily loaded builder.
        postPatch = (assetsOld.postPatch or "") + ''
          substituteInPlace module/codemirror-promql/src/complete/hybrid.test.ts \
            --replace-fail "it(value.title, () => {" \
            "(value.title === 'autocomplete topk params 2' ? it.skip : it)(value.title, () => {"
          substituteInPlace module/codemirror-promql/src/parser/vector.test.ts \
            --replace-fail "it(value.binaryExpr, () => {" \
            "(value.binaryExpr === 'foo * on(test,blub) bar' ? it.skip : it)(value.binaryExpr, () => {"
        '';
      });
    in
    {
      postPatch = builtins.replaceStrings [ "${old.passthru.assets}" ] [ "${assets}" ] (
        builtins.unsafeDiscardStringContext old.postPatch
      );
      passthru = old.passthru // {
        inherit assets;
      };
    }
  );

  pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [
    (_pythonFinal: pythonPrev: {
      backrefs = pythonPrev.backrefs.overridePythonAttrs (old: {
        # regex measures its timeout in process CPU time, while this test used
        # wall time and could miss the timeout when a busy builder descheduled it.
        postPatch = (old.postPatch or "") + ''
          substituteInPlace tests/test_bregex.py \
            --replace-fail "time.time()" "time.process_time()"
        '';
      });

      pytest-xdist = pythonPrev.pytest-xdist.overridePythonAttrs (old: {
        # The suite exercises its own worker pools. Run the outer suite with one
        # worker and allow inner workers more time on heavily loaded builders.
        postPatch = (old.postPatch or "") + ''
          substituteInPlace testing/test_remote.py \
            --replace-fail "WAIT_TIMEOUT = 10.0" "WAIT_TIMEOUT = 60.0"
        '';
        preCheck = builtins.replaceStrings [ "--numprocesses=$NIX_BUILD_CORES" ] [ "--numprocesses=1" ] (
          old.preCheck or ""
        );
        # This test deliberately crashes workers past the restart limit and
        # races while checking which replacement message was emitted.
        disabledTests = (old.disabledTests or [ ]) ++ [
          "test_max_worker_restart_tests_queued"
        ];
      });

      jupyter-server = pythonPrev.jupyter-server.overridePythonAttrs (old: {
        # The kernel reply arrived after the one-second outer deadline when the
        # builder was heavily loaded. Keep the regression test but allow it the
        # same margin as the other resource-sensitive tests.
        postPatch = (old.postPatch or "") + ''
          substituteInPlace tests/services/kernels/test_connection.py \
            --replace-fail \
            "await asyncio.wait_for(asyncio.wrap_future(conn2.request_kernel_info()), timeout=1.0)" \
            "await asyncio.wait_for(asyncio.wrap_future(conn2.request_kernel_info()), timeout=10.0)"
        '';
      });

      scipy = pythonPrev.scipy.overridePythonAttrs (old: {
        # x86-64-v3 FFT implementations produce rounding differences outside
        # these tests' strict tolerances. We accept the numerical-precision
        # risk for our workloads.
        disabledTests = (old.disabledTests or [ ]) ++ [
          "test_roundtrip_float32"
          "test_roundtrip_scaling"
        ];
      });

      sentry-sdk = pythonPrev.sentry-sdk.overridePythonAttrs (old: {
        # This test globally mocks threading.current_thread while another
        # thread is running. On Python 3.14, Thread.join can race with that
        # mock and exhaust its single side effect before the worker removes it.
        disabledTests = (old.disabledTests or [ ]) ++ [
          "test_get_current_thread_meta_main_thread"
        ];
      });

      torchcodec = pythonPrev.torchcodec.overridePythonAttrs (old: {
        # For these 8 kHz MP3 cases, the x86-64-v3 API and CLI codec paths
        # differ in 0.8% of decoded samples. Retain the original tolerance for
        # 99% of samples and accept the localized audio-precision risk.
        postPatch = (old.postPatch or "") + ''
          substituteInPlace test/test_encoders.py \
            --replace-fail \
            'if sys.platform == "darwin":' \
            'if sys.platform == "darwin" or (
                format == "mp3"
                and sample_rate == 8_000
                and asset is SINE_MONO_S32
                and bit_rate in (None, 0)
                and num_channels in (None, 1)
            ):'
        '';
      });
    })
  ];
}