TST: adjust other very slow tests

scipy/_lib/tests/test_import_cycles.py

@@ -1,3 +1,4 @@
+import pytest
 import sys
 import subprocess
 
@@ -7,6 +8,7 @@
 # Check that all modules are importable in a new Python process.
 # This is not necessarily true if there are import cycles present.
 
+@pytest.mark.slow
 def test_public_modules_importable():
     pids = [subprocess.Popen([sys.executable, '-c', f'import {module}'])
             for module in PUBLIC_MODULES]

scipy/integrate/tests/test_quadpack.py

@@ -342,6 +342,7 @@ def simpfunc(z, y, x, t):      # Note order of arguments.
                             (2.,)),
                      2*8/3.0 * (b**4.0 - a**4.0))
 
+    @pytest.mark.xslow
     @pytest.mark.parametrize(
         "x_lower, x_upper, y_lower, y_upper, z_lower, z_upper, expected",
         [

scipy/interpolate/tests/test_gil.py

@@ -28,7 +28,7 @@ def run(self):
 
         return WorkerThread()
 
-    @pytest.mark.slow
+    @pytest.mark.xslow
     @pytest.mark.xfail(reason='race conditions, may depend on system load')
     def test_rectbivariatespline(self):
         def generate_params(n_points):

scipy/interpolate/tests/test_rgi.py

@@ -476,7 +476,7 @@ def f(x, y):
     ])
     def test_descending_points_nd(self, method, ndims, func):
 
-        if ndims == 5 and method in {"cubic", "quintic"}:
+        if ndims >= 4 and method in {"cubic", "quintic"}:
             pytest.skip("too slow; OOM (quintic); or nearly so (cubic)")
 
         rng = np.random.default_rng(42)

scipy/optimize/tests/test__differential_evolution.py

@@ -1339,7 +1339,7 @@ def c1(x):
         assert_(np.all(res.x >= np.array(bounds)[:, 0]))
         assert_(np.all(res.x <= np.array(bounds)[:, 1]))
 
-    @pytest.mark.slow
+    @pytest.mark.xslow
     @pytest.mark.xfail(platform.machine() == 'ppc64le',
                        reason="fails on ppc64le")
     def test_L8(self):

scipy/optimize/tests/test_extending.py

@@ -5,7 +5,6 @@
 
 from scipy._lib._testutils import _test_cython_extension, cython
 
-
 @pytest.mark.skipif(platform.machine() in ["wasm32", "wasm64"],
                     reason="Can't start subprocess")
 @pytest.mark.skipif(cython is None, reason="requires cython")

scipy/optimize/tests/test_minimize_constrained.py

@@ -2,7 +2,7 @@
 import pytest
 from scipy.linalg import block_diag
 from scipy.sparse import csc_matrix
-from numpy.testing import (TestCase, assert_array_almost_equal,
+from numpy.testing import (assert_array_almost_equal,
                            assert_array_less, assert_, assert_allclose,
                            suppress_warnings)
 from scipy.optimize import (NonlinearConstraint,
@@ -443,67 +443,70 @@ def hess(x, v):
         return NonlinearConstraint(fun, -np.inf, 0, jac, hess)
 
 
-class TestTrustRegionConstr(TestCase):
-
-    @pytest.mark.slow
-    def test_list_of_problems(self):
-        list_of_problems = [Maratos(),
-                            Maratos(constr_hess='2-point'),
-                            Maratos(constr_hess=SR1()),
-                            Maratos(constr_jac='2-point', constr_hess=SR1()),
-                            MaratosGradInFunc(),
-                            HyperbolicIneq(),
-                            HyperbolicIneq(constr_hess='3-point'),
-                            HyperbolicIneq(constr_hess=BFGS()),
-                            HyperbolicIneq(constr_jac='3-point',
-                                           constr_hess=BFGS()),
-                            Rosenbrock(),
-                            IneqRosenbrock(),
-                            EqIneqRosenbrock(),
-                            BoundedRosenbrock(),
-                            Elec(n_electrons=2),
-                            Elec(n_electrons=2, constr_hess='2-point'),
-                            Elec(n_electrons=2, constr_hess=SR1()),
-                            Elec(n_electrons=2, constr_jac='3-point',
-                                 constr_hess=SR1())]
-
-        for prob in list_of_problems:
-            for grad in (prob.grad, '3-point', False):
-                for hess in (prob.hess,
-                             '3-point',
-                             SR1(),
-                             BFGS(exception_strategy='damp_update'),
-                             BFGS(exception_strategy='skip_update')):
-
-                    # Remove exceptions
-                    if grad in ('2-point', '3-point', 'cs', False) and \
-                       hess in ('2-point', '3-point', 'cs'):
-                        continue
-                    if prob.grad is True and grad in ('3-point', False):
-                        continue
-                    with suppress_warnings() as sup:
-                        sup.filter(UserWarning, "delta_grad == 0.0")
-                        result = minimize(prob.fun, prob.x0,
-                                          method='trust-constr',
-                                          jac=grad, hess=hess,
-                                          bounds=prob.bounds,
-                                          constraints=prob.constr)
-
-                    if prob.x_opt is not None:
-                        assert_array_almost_equal(result.x, prob.x_opt,
-                                                  decimal=5)
-                        # gtol
-                        if result.status == 1:
-                            assert_array_less(result.optimality, 1e-8)
-                    # xtol
-                    if result.status == 2:
-                        assert_array_less(result.tr_radius, 1e-8)
-
-                        if result.method == "tr_interior_point":
-                            assert_array_less(result.barrier_parameter, 1e-8)
-                    # max iter
-                    if result.status in (0, 3):
-                        raise RuntimeError("Invalid termination condition.")
+class TestTrustRegionConstr:
+    list_of_problems = [Maratos(),
+                        Maratos(constr_hess='2-point'),
+                        Maratos(constr_hess=SR1()),
+                        Maratos(constr_jac='2-point', constr_hess=SR1()),
+                        MaratosGradInFunc(),
+                        HyperbolicIneq(),
+                        HyperbolicIneq(constr_hess='3-point'),
+                        HyperbolicIneq(constr_hess=BFGS()),
+                        HyperbolicIneq(constr_jac='3-point',
+                                       constr_hess=BFGS()),
+                        Rosenbrock(),
+                        IneqRosenbrock(),
+                        EqIneqRosenbrock(),
+                        BoundedRosenbrock(),
+                        Elec(n_electrons=2),
+                        Elec(n_electrons=2, constr_hess='2-point'),
+                        Elec(n_electrons=2, constr_hess=SR1()),
+                        Elec(n_electrons=2, constr_jac='3-point',
+                             constr_hess=SR1())]
+
+    @pytest.mark.parametrize('prob', list_of_problems)
+    @pytest.mark.parametrize('grad', ('prob.grad', '3-point', False))
+    @pytest.mark.parametrize('hess', ("prob.hess", '3-point', SR1(),
+                                      BFGS(exception_strategy='damp_update'),
+                                      BFGS(exception_strategy='skip_update')))
+    def test_list_of_problems(self, prob, grad, hess):
+        grad = prob.grad if grad == "prob.grad" else grad
+        hess = prob.hess if hess == "prob.hess" else hess
+        # Remove exceptions
+        if (grad in {'2-point', '3-point', 'cs', False} and
+                hess in {'2-point', '3-point', 'cs'}):
+            pytest.skip("Numerical Hessian needs analytical gradient")
+        if prob.grad is True and grad in {'3-point', False}:
+            pytest.skip("prob.grad incompatible with grad in {'3-point', False}")
+        sensitive = (isinstance(prob, BoundedRosenbrock) and grad == '3-point'
+                     and isinstance(hess, BFGS))
+        if sensitive:
+            pytest.xfail("Seems sensitive to initial conditions w/ Accelerate")
+        with suppress_warnings() as sup:
+            sup.filter(UserWarning, "delta_grad == 0.0")
+            result = minimize(prob.fun, prob.x0,
+                              method='trust-constr',
+                              jac=grad, hess=hess,
+                              bounds=prob.bounds,
+                              constraints=prob.constr)
+
+        if prob.x_opt is not None:
+            assert_array_almost_equal(result.x, prob.x_opt,
+                                      decimal=5)
+            # gtol
+            if result.status == 1:
+                assert_array_less(result.optimality, 1e-8)
+        # xtol
+        if result.status == 2:
+            assert_array_less(result.tr_radius, 1e-8)
+
+            if result.method == "tr_interior_point":
+                assert_array_less(result.barrier_parameter, 1e-8)
+
+        # check for max iter
+        message = f"Invalid termination condition: {result.status}."
+        assert result.status not in {0, 3}, message
+
 
     def test_default_jac_and_hess(self):
         def fun(x):
@@ -641,7 +644,7 @@ def obj(x):
 
         assert result['success']
 
-class TestEmptyConstraint(TestCase):
+class TestEmptyConstraint:
     """
     Here we minimize x^2+y^2 subject to x^2-y^2>1.
     The actual minimum is at (0, 0) which fails the constraint.

scipy/sparse/linalg/_eigen/lobpcg/tests/test_lobpcg.py

@@ -533,7 +533,7 @@ def test_maxit():
     assert_allclose(np.shape(r_h), np.shape(np.asarray(r_h)))
 
 
-@pytest.mark.slow
+@pytest.mark.xslow
 @pytest.mark.parametrize("n", [15])
 @pytest.mark.parametrize("m", [1, 2])
 @pytest.mark.filterwarnings("ignore:Exited at iteration")

scipy/sparse/linalg/tests/test_propack.py

@@ -89,6 +89,7 @@ def test_svdp(ctor, dtype, irl, which):
         check_svdp(n, m, ctor, dtype, k, irl, which)
 
 
+@pytest.mark.xslow
 @pytest.mark.parametrize('dtype', _dtypes)
 @pytest.mark.parametrize('irl', (False, True))
 @pytest.mark.timeout(120)  # True, complex64 > 60 s: prerel deps cov 64bit blas

scipy/spatial/tests/test_qhull.py

@@ -344,7 +344,7 @@ def test_degenerate_barycentric_transforms(self):
         # Check the transforms
         self._check_barycentric_transforms(tri)
 
-    @pytest.mark.slow
+    @pytest.mark.xslow
     def test_more_barycentric_transforms(self):
         # Triangulate some "nasty" grids