From: Colin Watson <cjwatson@debian.org>
Date: Sun, 19 Oct 2025 02:05:19 +0100
Subject: Stop using private sklearn.utils._testing

Forwarded: https://github.com/trevorstephens/gplearn/pull/305
Bug-Debian: https://bugs.debian.org/1117991
Last-Update: 2025-10-19
---
 gplearn/tests/test_examples.py  |   2 +-
 gplearn/tests/test_fitness.py   |  40 +++++-----
 gplearn/tests/test_functions.py |  85 +++++++--------------
 gplearn/tests/test_genetic.py   | 165 ++++++++++++++++++++++++++--------------
 gplearn/tests/test_utils.py     |   8 +-
 5 files changed, 158 insertions(+), 142 deletions(-)

diff --git a/gplearn/tests/test_examples.py b/gplearn/tests/test_examples.py
index f4f3f89..7bf5b2a 100644
--- a/gplearn/tests/test_examples.py
+++ b/gplearn/tests/test_examples.py
@@ -6,13 +6,13 @@
 
 import numpy as np
 
+from numpy.testing import assert_almost_equal
 from sklearn.datasets import load_diabetes, load_breast_cancer
 from sklearn.datasets import make_moons, make_circles, make_classification
 from sklearn.linear_model import Ridge
 from sklearn.metrics import roc_auc_score
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
-from sklearn.utils._testing import assert_almost_equal
 from sklearn.utils.validation import check_random_state
 
 from gplearn.genetic import SymbolicClassifier, SymbolicRegressor
diff --git a/gplearn/tests/test_fitness.py b/gplearn/tests/test_fitness.py
index a189126..4046b73 100644
--- a/gplearn/tests/test_fitness.py
+++ b/gplearn/tests/test_fitness.py
@@ -7,9 +7,9 @@
 import pickle
 
 import numpy as np
+import pytest
 from sklearn.datasets import load_diabetes, load_breast_cancer
 from sklearn.metrics import mean_absolute_error
-from sklearn.utils._testing import assert_raises
 from sklearn.utils.validation import check_random_state
 
 from gplearn.genetic import SymbolicRegressor, SymbolicClassifier
@@ -35,35 +35,27 @@ def test_validate_fitness():
     # Check arg count checks
     _ = make_fitness(function=_mean_square_error, greater_is_better=True)
     # non-bool greater_is_better
-    assert_raises(ValueError,
-                  make_fitness,
-                  function=_mean_square_error,
-                  greater_is_better='Sure')
-    assert_raises(ValueError,
-                  make_fitness,
-                  function=_mean_square_error,
-                  greater_is_better=1)
+    with pytest.raises(ValueError):
+        make_fitness(function=_mean_square_error, greater_is_better='Sure')
+    with pytest.raises(ValueError):
+        make_fitness(function=_mean_square_error, greater_is_better=1)
     # non-bool wrap
-    assert_raises(ValueError,
-                  make_fitness,
-                  function=_mean_square_error,
-                  greater_is_better=True, wrap='f')
+    with pytest.raises(ValueError):
+        make_fitness(function=_mean_square_error,
+                     greater_is_better=True,
+                     wrap='f')
 
     # Check arg count tests
     def bad_fun1(x1, x2):
         return 1.0
-    assert_raises(ValueError,
-                  make_fitness,
-                  function=bad_fun1,
-                  greater_is_better=True)
+    with pytest.raises(ValueError):
+        make_fitness(function=bad_fun1, greater_is_better=True)
 
     # Check return type tests
     def bad_fun2(x1, x2, w):
         return 'ni'
-    assert_raises(ValueError,
-                  make_fitness,
-                  function=bad_fun2,
-                  greater_is_better=True)
+    with pytest.raises(ValueError):
+        make_fitness(function=bad_fun2, greater_is_better=True)
 
     def _custom_metric(y, y_pred, w):
         """Calculate the root mean square error."""
@@ -211,11 +203,13 @@ def test_parallel_custom_metric():
                             random_state=0,
                             n_jobs=2)
     est.fit(diabetes.data, diabetes.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
 
     # Single threaded will also fail in non-interactive sessions
     est = SymbolicRegressor(generations=2,
                             metric=custom_metric,
                             random_state=0)
     est.fit(diabetes.data, diabetes.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
diff --git a/gplearn/tests/test_functions.py b/gplearn/tests/test_functions.py
index 5b4df74..8053e7c 100644
--- a/gplearn/tests/test_functions.py
+++ b/gplearn/tests/test_functions.py
@@ -7,9 +7,9 @@
 import pickle
 
 import numpy as np
+import pytest
 from numpy import maximum
 from sklearn.datasets import load_diabetes, load_breast_cancer
-from sklearn.utils._testing import assert_raises
 from sklearn.utils.validation import check_random_state
 
 from gplearn.functions import _protected_sqrt, make_function
@@ -36,79 +36,48 @@ def test_validate_function():
     # Check arity tests
     _ = make_function(function=_protected_sqrt, name='sqrt', arity=1)
     # non-integer arity
-    assert_raises(ValueError,
-                  make_function,
-                  function=_protected_sqrt,
-                  name='sqrt',
-                  arity='1')
-    assert_raises(ValueError,
-                  make_function,
-                  function=_protected_sqrt,
-                  name='sqrt',
-                  arity=1.0)
+    with pytest.raises(ValueError):
+        make_function(function=_protected_sqrt, name='sqrt', arity='1')
+    with pytest.raises(ValueError):
+        make_function(function=_protected_sqrt, name='sqrt', arity=1.0)
     # non-bool wrap
-    assert_raises(ValueError,
-                  make_function,
-                  function=_protected_sqrt,
-                  name='sqrt',
-                  arity=1,
-                  wrap='f')
+    with pytest.raises(ValueError):
+        make_function(function=_protected_sqrt, name='sqrt', arity=1, wrap='f')
     # non-matching arity
-    assert_raises(ValueError,
-                  make_function,
-                  function=_protected_sqrt,
-                  name='sqrt',
-                  arity=2)
-    assert_raises(ValueError,
-                  make_function,
-                  function=maximum,
-                  name='max',
-                  arity=1)
+    with pytest.raises(ValueError):
+        make_function(function=_protected_sqrt, name='sqrt', arity=2)
+    with pytest.raises(ValueError):
+        make_function(function=maximum, name='max', arity=1)
 
     # Check name test
-    assert_raises(ValueError,
-                  make_function,
-                  function=_protected_sqrt,
-                  name=2,
-                  arity=1)
+    with pytest.raises(ValueError):
+        make_function(function=_protected_sqrt, name=2, arity=1)
 
     # Check return type tests
     def bad_fun1(x1, x2):
         return 'ni'
-    assert_raises(ValueError,
-                  make_function,
-                  function=bad_fun1,
-                  name='ni',
-                  arity=2)
+    with pytest.raises(ValueError):
+        make_function(function=bad_fun1, name='ni', arity=2)
 
     # Check return shape tests
     def bad_fun2(x1):
         return np.ones((2, 1))
-    assert_raises(ValueError,
-                  make_function,
-                  function=bad_fun2,
-                  name='ni',
-                  arity=1)
+    with pytest.raises(ValueError):
+        make_function(function=bad_fun2, name='ni', arity=1)
 
     # Check closure for negatives test
     def _unprotected_sqrt(x1):
         with np.errstate(divide='ignore', invalid='ignore'):
             return np.sqrt(x1)
-    assert_raises(ValueError,
-                  make_function,
-                  function=_unprotected_sqrt,
-                  name='sqrt',
-                  arity=1)
+    with pytest.raises(ValueError):
+        make_function(function=_unprotected_sqrt, name='sqrt', arity=1)
 
     # Check closure for zeros test
     def _unprotected_div(x1, x2):
         with np.errstate(divide='ignore', invalid='ignore'):
             return np.divide(x1, x2)
-    assert_raises(ValueError,
-                  make_function,
-                  function=_unprotected_div,
-                  name='div',
-                  arity=2)
+    with pytest.raises(ValueError):
+        make_function(function=_unprotected_div, name='div', arity=2)
 
 
 def test_function_in_program():
@@ -160,14 +129,16 @@ def test_parallel_custom_function():
                             random_state=0,
                             n_jobs=2)
     est.fit(diabetes.data, diabetes.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
 
     # Single threaded will also fail in non-interactive sessions
     est = SymbolicRegressor(generations=2,
                             function_set=['add', 'sub', 'mul', 'div', logical],
                             random_state=0)
     est.fit(diabetes.data, diabetes.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
 
 
 def test_parallel_custom_transformer():
@@ -197,11 +168,13 @@ def test_parallel_custom_transformer():
                              random_state=0,
                              n_jobs=2)
     est.fit(cancer.data, cancer.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
 
     # Single threaded will also fail in non-interactive sessions
     est = SymbolicClassifier(generations=2,
                              transformer=sigmoid,
                              random_state=0)
     est.fit(cancer.data, cancer.target)
-    assert_raises(AttributeError, pickle.dumps, est)
+    with pytest.raises(AttributeError):
+        pickle.dumps(est)
diff --git a/gplearn/tests/test_genetic.py b/gplearn/tests/test_genetic.py
index 1364d51..d7e59c0 100644
--- a/gplearn/tests/test_genetic.py
+++ b/gplearn/tests/test_genetic.py
@@ -7,11 +7,14 @@ gplearn.genetic.SymbolicRegressor and gplearn.genetic.SymbolicTransformer."""
 # License: BSD 3 clause
 
 import pickle
-import pytest
 import sys
 from io import StringIO
 
 import numpy as np
+import pytest
+from numpy.testing import assert_almost_equal
+from numpy.testing import assert_array_equal
+from numpy.testing import assert_array_almost_equal
 from scipy.stats import pearsonr, spearmanr
 from sklearn.datasets import load_diabetes, load_breast_cancer
 from sklearn.metrics import mean_absolute_error
@@ -19,10 +22,6 @@ from sklearn.model_selection import GridSearchCV
 from sklearn.pipeline import make_pipeline
 from sklearn.preprocessing import StandardScaler
 from sklearn.tree import DecisionTreeRegressor
-from sklearn.utils._testing import assert_almost_equal
-from sklearn.utils._testing import assert_array_equal
-from sklearn.utils._testing import assert_array_almost_equal
-from sklearn.utils._testing import assert_raises
 from sklearn.utils.validation import check_random_state
 
 from gplearn.genetic import SymbolicClassifier, SymbolicRegressor
@@ -175,14 +174,16 @@ def test_validate_program():
                  random_state, program=test_gp)
 
     # Now try a couple that shouldn't be
-    assert_raises(ValueError, _Program, function_set, arities, init_depth,
-                  init_method, n_features, const_range, metric,
-                  p_point_replace, parsimony_coefficient, random_state,
-                  program=test_gp[:-1])
-    assert_raises(ValueError, _Program, function_set, arities, init_depth,
-                  init_method, n_features, const_range, metric,
-                  p_point_replace, parsimony_coefficient, random_state,
-                  program=test_gp + [1])
+    with pytest.raises(ValueError):
+        _Program(function_set, arities, init_depth,
+                 init_method, n_features, const_range, metric,
+                 p_point_replace, parsimony_coefficient, random_state,
+                 program=test_gp[:-1])
+    with pytest.raises(ValueError):
+        _Program(function_set, arities, init_depth,
+                 init_method, n_features, const_range, metric,
+                 p_point_replace, parsimony_coefficient, random_state,
+                 program=test_gp + [1])
 
 
 def test_print_overloading():
@@ -304,12 +305,14 @@ def test_invalid_feature_names():
 
         # Check invalid length feature_names
         est = Symbolic(feature_names=['foo', 'bar'])
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
         # Check invalid type feature_name
         feature_names = [str(n) for n in range(12)] + [0]
         est = Symbolic(feature_names=feature_names)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
 
 def test_execute():
@@ -435,21 +438,27 @@ def test_input_validation():
     for Symbolic in (SymbolicRegressor, SymbolicTransformer):
         # Check too much proba
         est = Symbolic(p_point_mutation=.5)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
         # Check invalid init_method
         est = Symbolic(init_method='ni')
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
         # Check invalid const_ranges
         est = Symbolic(const_range=2)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(const_range=[2, 2])
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(const_range=(2, 2, 2))
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(const_range='ni')
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         # And check acceptable, but strange, representations of const_range
         est = Symbolic(population_size=100, generations=1, const_range=(2, 2))
         est.fit(diabetes.data, diabetes.target)
@@ -460,30 +469,40 @@ def test_input_validation():
 
         # Check invalid init_depth
         est = Symbolic(init_depth=2)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(init_depth=2)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(init_depth=[2, 2])
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(init_depth=(2, 2, 2))
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(init_depth='ni')
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(init_depth=(4, 2))
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         # And check acceptable, but strange, representations of init_depth
         est = Symbolic(population_size=100, generations=1, init_depth=(2, 2))
         est.fit(diabetes.data, diabetes.target)
 
     # Check hall_of_fame and n_components for transformer
     est = SymbolicTransformer(hall_of_fame=2000)
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
     est = SymbolicTransformer(n_components=2000)
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
     est = SymbolicTransformer(hall_of_fame=0)
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
     est = SymbolicTransformer(n_components=0)
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
 
     # Check regressor metrics
     for m in ['mean absolute error', 'mse', 'rmse', 'pearson', 'spearman']:
@@ -491,7 +510,8 @@ def test_input_validation():
         est.fit(diabetes.data, diabetes.target)
     # And check a fake one
     est = SymbolicRegressor(metric='the larch')
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
     # Check transformer metrics
     for m in ['pearson', 'spearman']:
         est = SymbolicTransformer(population_size=100, generations=1, metric=m)
@@ -499,7 +519,8 @@ def test_input_validation():
     # And check the regressor metrics as well as a fake one
     for m in ['mean absolute error', 'mse', 'rmse', 'the larch']:
         est = SymbolicTransformer(metric=m)
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
 
 def test_input_validation_classifier():
@@ -507,21 +528,27 @@ def test_input_validation_classifier():
 
     # Check too much proba
     est = SymbolicClassifier(p_point_mutation=.5)
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
 
     # Check invalid init_method
     est = SymbolicClassifier(init_method='ni')
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
 
     # Check invalid const_ranges
     est = SymbolicClassifier(const_range=2)
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(const_range=[2, 2])
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(const_range=(2, 2, 2))
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(const_range='ni')
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     # And check acceptable, but strange, representations of const_range
     est = SymbolicClassifier(population_size=100, generations=1,
                              const_range=(2, 2))
@@ -535,17 +562,23 @@ def test_input_validation_classifier():
 
     # Check invalid init_depth
     est = SymbolicClassifier(init_depth=2)
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(init_depth=2)
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(init_depth=[2, 2])
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(init_depth=(2, 2, 2))
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(init_depth='ni')
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(init_depth=(4, 2))
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     # And check acceptable, but strange, representations of init_depth
     est = SymbolicClassifier(population_size=100, generations=1,
                              init_depth=(2, 2))
@@ -557,7 +590,8 @@ def test_input_validation_classifier():
         est.fit(cancer.data, cancer.target)
     # And check a fake one
     est = SymbolicClassifier(metric='the larch')
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
 
     # Check classifier transformers
     for t in ['sigmoid']:
@@ -566,10 +600,12 @@ def test_input_validation_classifier():
         est.fit(cancer.data, cancer.target)
     # And check an incompatible one with wrong arity
     est = SymbolicClassifier(transformer=sub2)
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     # And check a fake one
     est = SymbolicClassifier(transformer='the larch')
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
 
 
 def test_none_const_range():
@@ -997,7 +1033,8 @@ def test_transformer_iterable():
     assert np.allclose(fitted_iter, expected_iter, atol=1)
 
     # Check IndexError
-    assert_raises(IndexError, est.__getitem__, 10)
+    with pytest.raises(IndexError):
+        est[10]
 
 
 def test_print_overloading_estimator():
@@ -1137,12 +1174,15 @@ def test_validate_functions():
         # These should fail
         est = Symbolic(generations=2, random_state=0,
                        function_set=('ni', 'sub', 'mul', div2))
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(generations=2, random_state=0,
                        function_set=(7, 'sub', 'mul', div2))
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
         est = Symbolic(generations=2, random_state=0, function_set=())
-        assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+        with pytest.raises(ValueError):
+            est.fit(diabetes.data, diabetes.target)
 
     # Now for the classifier... These should be fine
     est = SymbolicClassifier(population_size=100, generations=2,
@@ -1157,12 +1197,15 @@ def test_validate_functions():
     # These should fail
     est = SymbolicClassifier(generations=2, random_state=0,
                              function_set=('ni', 'sub', 'mul', div2))
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(generations=2, random_state=0,
                              function_set=(7, 'sub', 'mul', div2))
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
     est = SymbolicClassifier(generations=2, random_state=0, function_set=())
-    assert_raises(ValueError, est.fit, cancer.data, cancer.target)
+    with pytest.raises(ValueError):
+        est.fit(cancer.data, cancer.target)
 
 
 def test_indices():
@@ -1181,13 +1224,16 @@ def test_indices():
     test_gp = [mul2, div2, 8, 1, sub2, 9, .5]
     gp = _Program(random_state=random_state, program=test_gp, **params)
 
-    assert_raises(ValueError, gp.get_all_indices)
-    assert_raises(ValueError, gp._indices)
+    with pytest.raises(ValueError):
+        gp.get_all_indices()
+    with pytest.raises(ValueError):
+        gp._indices()
 
     def get_indices_property():
         return gp.indices_
 
-    assert_raises(ValueError, get_indices_property)
+    with pytest.raises(ValueError):
+        get_indices_property()
 
     indices, _ = gp.get_all_indices(10, 7, random_state)
 
@@ -1222,7 +1268,8 @@ def test_warm_start():
 
     # Check fitting fewer generations raises error
     est.set_params(generations=5, warm_start=True)
-    assert_raises(ValueError, est.fit, diabetes.data, diabetes.target)
+    with pytest.raises(ValueError):
+        est.fit(diabetes.data, diabetes.target)
 
     # Check fitting the same number of generations warns
     est.set_params(generations=10, warm_start=True)
diff --git a/gplearn/tests/test_utils.py b/gplearn/tests/test_utils.py
index 6420e7a..82b8333 100644
--- a/gplearn/tests/test_utils.py
+++ b/gplearn/tests/test_utils.py
@@ -5,7 +5,7 @@
 # License: BSD 3 clause
 
 import numpy as np
-from sklearn.utils._testing import assert_raises
+import pytest
 
 from gplearn.utils import _get_n_jobs, check_random_state, cpu_count
 
@@ -25,7 +25,8 @@ def test_check_random_state():
     rng_42 = np.random.RandomState(42)
     assert(check_random_state(43).randint(100) != rng_42.randint(100))
 
-    assert_raises(ValueError, check_random_state, "some invalid seed")
+    with pytest.raises(ValueError):
+        check_random_state("some invalid seed")
 
 
 def test_get_n_jobs():
@@ -39,4 +40,5 @@ def test_get_n_jobs():
     jobs = _get_n_jobs(jobs)
     assert(jobs == expected)
 
-    assert_raises(ValueError, _get_n_jobs, 0)
+    with pytest.raises(ValueError):
+        _get_n_jobs(0)