MAINT: Trim redundant RNG tests

Author: bruAristimunha

mne/preprocessing/tests/test_ica.py

@@ -292,7 +292,6 @@ def test_ica_max_iter_(method, max_iter_default):
 
 def test_ica_rng_transition():
     """Test the transition from random_state to rng."""
-    _ICA(random_state=0)
     with pytest.raises(TypeError, match="only one"):
         _ICA(random_state=0, rng=0)
 
@@ -301,46 +300,26 @@ def test_ica_rng_transition():
         info["highpass"] = 1.0
     raw = RawArray(np.random.default_rng(0).standard_normal((3, 200)), info)
     unmixings = []
-    for random_state in (0, check_random_state(0)):
+    for kwargs in (
+        dict(random_state=0),
+        dict(random_state=check_random_state(0)),
+        dict(rng=0),
+    ):
         ica = _ICA(
             n_components=2,
             method="fastica",
             max_iter=1000,
-            random_state=random_state,
+            **kwargs,
         )
         with _record_warnings():  # ICA does not necessarily converge
             ica.fit(raw)
         unmixings.append(ica.unmixing_matrix_)
-    ica = _ICA(n_components=2, method="fastica", max_iter=1000, rng=0)
-    with _record_warnings():  # ICA does not necessarily converge
-        ica.fit(raw)
-    unmixings.append(ica.unmixing_matrix_)
     assert_array_equal(unmixings[0], unmixings[1])
     # at the ICA/sklearn boundary an integer ``rng`` seed is forwarded verbatim,
-    # so it matches the same integer passed to the deprecated parameter
+    # so it matches the same integer passed to the legacy parameter
     assert_array_equal(unmixings[0], unmixings[2])
 
 
-def test_ica_infomax_fit_params_verbose():
-    """Test Infomax fit_params can suppress its private logging scope."""
-    info = create_info(["Fz", "Cz", "Pz"], 100.0, "eeg")
-    with info._unlock():
-        info["highpass"] = 1.0
-    raw = RawArray(np.random.default_rng(0).standard_normal((3, 200)), info)
-    ica = _ICA(
-        n_components=2,
-        method="infomax",
-        fit_params={"verbose": False},
-        max_iter=1,
-        rng=0,
-    )
-    with catch_logging(True) as log:
-        ica.fit(raw, verbose=True)
-    log = log.getvalue()
-    assert "Fitting ICA to data" in log
-    assert "Computing Infomax ICA" not in log
-
-
 @pytest.mark.parametrize("method", ["infomax", "fastica", "picard"])
 def test_ica_n_iter_(method, tmp_path):
     """Test that ICA.n_iter_ is set after fitting."""

mne/simulation/tests/test_source.py

@@ -7,7 +7,6 @@
 from numpy.testing import assert_array_almost_equal, assert_array_equal, assert_equal
 
 from mne import (
-    SourceSpaces,
     convert_forward_solution,
     pick_types_forward,
     read_forward_solution,
@@ -16,7 +15,6 @@
 from mne.datasets import testing
 from mne.label import Label
 from mne.simulation import SourceSimulator, simulate_sparse_stc, simulate_stc
-from mne.utils import check_random_state
 
 data_path = testing.data_path(download=False)
 fname_fwd = data_path / "MEG" / "sample" / "sample_audvis_trunc-meg-eeg-oct-6-fwd.fif"
@@ -49,38 +47,6 @@ def _get_idx_label_stc(label, stc):
     return idx
 
 
-def test_simulate_sparse_stc_legacy_rng_nested():
-    """Test legacy RNGs survive nested label-source selection."""
-    src = SourceSpaces(
-        [
-            dict(
-                type="surf",
-                vertno=np.arange(1, 4) + 3 * hemi,
-                nuse=3,
-                subject_his_id="sample",
-            )
-            for hemi in range(2)
-        ]
-    )
-    labels = [
-        Label(np.arange(1, 4) + 3 * idx, hemi=hemi, subject="sample")
-        for idx, hemi in enumerate(("lh", "rh"))
-    ]
-    results = []
-    for random_state in (0, check_random_state(0)):
-        results.append(
-            simulate_sparse_stc(
-                src,
-                2,
-                np.arange(2.0),
-                labels=labels,
-                random_state=random_state,
-            )
-        )
-    for hemi in (0, 1):
-        assert_array_equal(results[0].vertices[hemi], results[1].vertices[hemi])
-
-
 def test_simulate_stc(_get_fwd_labels):
     """Test generation of source estimate."""
     fwd, labels = _get_fwd_labels

mne/stats/tests/test_cluster_level.py

@@ -28,7 +28,7 @@
     summarize_clusters_stc,
     ttest_1samp_no_p,
 )
-from mne.utils import _record_warnings, catch_logging, check_random_state
+from mne.utils import _record_warnings, catch_logging
 
 n_space = 50
 
@@ -56,41 +56,6 @@ def _get_conditions():
     return condition1_1d, condition2_1d, condition1_2d, condition2_2d
 
 
-@pytest.mark.parametrize(
-    "function, make_X",
-    (
-        (
-            spatio_temporal_cluster_1samp_test,
-            lambda rng: rng.standard_normal((8, 3, 1)),
-        ),
-        (
-            spatio_temporal_cluster_test,
-            lambda rng: [
-                rng.standard_normal((8, 3, 1)),
-                rng.standard_normal((8, 3, 1)),
-            ],
-        ),
-    ),
-)
-def test_spatio_temporal_cluster_legacy_rng_nested(function, make_X):
-    """Test legacy RNGs survive nested spatio-temporal wrappers."""
-    data = make_X(np.random.default_rng(0))
-    results = []
-    for seed in (0, check_random_state(0)):
-        results.append(
-            function(
-                data,
-                threshold=0,
-                n_permutations=2,
-                seed=seed,
-                out_type="mask",
-            )
-        )
-    assert_array_equal(results[0][0], results[1][0])
-    assert_array_equal(results[0][2], results[1][2])
-    assert_array_equal(results[0][3], results[1][3])
-
-
 def test_thresholds(numba_conditional):
     """Test automatic threshold calculations."""
     # within subjects

mne/tests/test_cov.py

@@ -673,40 +673,6 @@ def get_data(n_samples, n_features, rank, sigma):
         )
 
 
-@pytest.mark.parametrize(
-    ("mode", "method_params"),
-    (
-        ("pca", dict(svd_solver="randomized")),
-        ("factor_analysis", dict(svd_method="randomized")),
-    ),
-)
-def test_auto_low_rank_ignores_global_rng(mode, method_params):
-    """Test low-rank covariance models use an explicit sklearn RNG state."""
-    pytest.importorskip("sklearn")
-    rng = np.random.default_rng(42)
-    mixing = rng.standard_normal((10, 10))
-    data = rng.standard_normal((400, 5))
-    data = data @ _safe_svd(mixing.copy())[0][:, :5].T
-    data += rng.normal(scale=0.1 * rng.random(10) + 0.05, size=data.shape)
-    data *= 1e8
-    global_rng = np.random.mtrand._rand
-    original_rng_state = global_rng.get_state()
-    try:
-        global_rng.set_state(np.random.RandomState(42).get_state())
-        global_rng_state = global_rng.get_state()
-        est, _ = _auto_low_rank_model(
-            data,
-            mode=mode,
-            n_jobs=1,
-            method_params=dict(iter_n_components=[4], **method_params),
-            cv=2,
-        )
-        assert_array_equal(global_rng.get_state()[1], global_rng_state[1])
-        assert est.random_state == 0
-    finally:
-        global_rng.set_state(original_rng_state)
-
-
 @pytest.mark.slowtest
 @pytest.mark.parametrize("rank", ("full", None, "info"))
 def test_compute_covariance_auto_reg(rank):

mne/tests/test_epochs.py

@@ -3021,44 +3021,6 @@ def test_equalize_epoch_counts_random():
     assert len(epochs_1) == len(epochs_2)
 
 
-@pytest.mark.parametrize(
-    "api, legacy, want",
-    (
-        ("counts", True, ([], [3, 4], [0, 3, 4])),
-        ("counts", False, ([], [1, 2], [0, 1, 2])),
-        ("events", True, [6, 7, 8, 11, 12]),
-        ("events", False, [4, 5, 8, 9, 10]),
-    ),
-)
-def test_equalize_epoch_counts_rng_streams(api, legacy, want):
-    """Test legacy integers re-seed while new RNG streams advance."""
-    info = create_info(["EEG 001"], 100.0, "eeg")
-    epochs = [
-        EpochsArray(
-            np.zeros((length, 1, 1)),
-            info,
-            events=np.column_stack(
-                (np.arange(length), np.zeros(length, int), np.full(length, code))
-            ),
-            event_id={str(code): code},
-            verbose=False,
-        )
-        for code, length in enumerate((3, 5, 6), 1)
-    ]
-    kwargs = {"random_state" if legacy else "rng": 0}
-    if api == "counts":
-        equalize_epoch_counts(epochs, method="random", **kwargs)
-        got = [
-            np.flatnonzero([entry == ("EQUALIZED_COUNT",) for entry in epoch.drop_log])
-            for epoch in epochs
-        ]
-    else:
-        epochs = concatenate_epochs(epochs)
-        _, got = epochs.equalize_event_counts(method="random", **kwargs)
-    for this_got, expected in zip(got, want, strict=True):
-        assert_array_equal(this_got, expected)
-
-
 def test_access_by_name(tmp_path):
     """Test accessing epochs by event name and on_missing for rare events."""
     raw, events, picks = _get_data()

mne/utils/tests/test_check.py

@@ -58,9 +58,6 @@ def test_check_rng():
     assert_array_equal(rng.integers(10, size=3), _check_rng(0).integers(10, size=3))
 
     assert _check_rng(rng) is rng
-    bit_generator = np.random.default_rng(0).bit_generator
-    assert isinstance(_check_rng(bit_generator.seed_seq), np.random.Generator)
-    assert isinstance(_check_rng(bit_generator), np.random.Generator)
     # legacy RandomState instances are passed through for scikit-learn interop
     random_state = np.random.RandomState(0)
     assert _check_rng(random_state) is random_state
@@ -81,9 +78,6 @@ def _func(random_state=None, seed=None, *, rng=None):
     # no argument: a fresh generator is created
     assert isinstance(_func(), np.random.Generator)
     assert isinstance(_func(rng=0), np.random.Generator)
-    assert_array_equal(
-        _func(rng=0).integers(10, size=3), _func(rng=0).integers(10, size=3)
-    )
     # legacy RandomState passthrough
     random_state = np.random.RandomState(0)
     assert _func(rng=random_state) is random_state

mne/utils/tests/test_numerics.py

@@ -4,7 +4,6 @@
 
 from copy import deepcopy
 from datetime import date
-from inspect import signature
 from io import StringIO
 from pathlib import Path
 
@@ -34,7 +33,6 @@
     _time_mask,
     _undo_scaling_array,
     _undo_scaling_cov,
-    check_random_state,
     compute_corr,
     create_slices,
     grand_average,
@@ -232,26 +230,6 @@ def test_random_permutation():
     )
 
 
-@pytest.mark.parametrize("use_keyword", (False, True))
-def test_random_permutation_legacy_none(use_keyword):
-    """Test explicit legacy None uses NumPy's global RandomState."""
-    global_rng = check_random_state(None)
-    original_state = global_rng.get_state()
-    want = np.array([6, 5, 4, 0, 3, 8, 9, 2, 7, 1])
-    try:
-        global_rng.set_state(check_random_state(42).get_state())
-        if use_keyword:
-            got = random_permutation(10, random_state=None)
-        else:
-            got = random_permutation(10, None)
-        assert_array_equal(got, want)
-    finally:
-        global_rng.set_state(original_state)
-    assert str(signature(random_permutation)) == (
-        "(n_samples, random_state=None, *, rng=None)"
-    )
-
-
 def test_cov_scaling():
     """Test rescaling covs."""
     evoked = read_evokeds(ave_fname, condition=0, baseline=(None, 0), proj=True)

mne/viz/tests/test_circle.py

@@ -6,7 +6,6 @@
 import matplotlib
 import numpy as np
 import pytest
-from numpy.testing import assert_allclose
 
 from mne.viz import plot_channel_labels_circle
 from mne.viz.circle import _plot_connectivity_circle
@@ -83,16 +82,3 @@ def test_plot_connectivity_circle_label_orientation():
                 f"Node '{name}' at {angle:.1f}° (left half) should have "
                 f"ha='right', got '{ha}'"
             )
-
-
-def test_plot_connectivity_circle_jitter_reproducible():
-    """Test connectivity-circle edge jitter uses a fixed local Generator."""
-    con = np.array([[0.0, 1.0, 2.0], [1.0, 0.0, 3.0], [2.0, 3.0, 0.0]])
-    vertices = []
-    for _ in range(2):
-        fig, ax = _plot_connectivity_circle(
-            con, ["a", "b", "c"], colorbar=False, interactive=False, show=False
-        )
-        vertices.append(ax.patches[0].get_path().vertices)
-        fig.clear()
-    assert_allclose(*vertices)