scipy 1.15.3__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0rc2__cp313-cp313t-macosx_14_0_arm64.whl

scipy/stats/tests/test_entropy.py

@@ -6,13 +6,13 @@ import numpy as np
 
 from scipy import stats
 from scipy.stats import norm, expon  # type: ignore[attr-defined]
-from scipy.conftest import array_api_compatible
-from scipy._lib._array_api import array_namespace, is_array_api_strict, is_jax
 from scipy._lib._array_api_no_0d import (xp_assert_close, xp_assert_equal,
                                          xp_assert_less)
 
+skip_xp_backends = pytest.mark.skip_xp_backends
+
+@pytest.mark.skip_xp_backends("dask.array", reason="boolean index assignment")
 class TestEntropy:
-    @array_api_compatible
     def test_entropy_positive(self, xp):
         # See ticket #497
         pk = xp.asarray([0.5, 0.2, 0.3])
@@ -22,33 +22,29 @@ class TestEntropy:
         xp_assert_equal(eself, xp.asarray(0.))
         xp_assert_less(-edouble, xp.asarray(0.))
 
-    @array_api_compatible
     def test_entropy_base(self, xp):
         pk = xp.ones(16)
         S = stats.entropy(pk, base=2.)
         xp_assert_less(xp.abs(S - 4.), xp.asarray(1.e-5))
 
         qk = xp.ones(16)
-        qk = xp.where(xp.arange(16) < 8, xp.asarray(2.), qk)
+        qk = xp.where(xp.arange(16) < 8, 2., qk)
         S = stats.entropy(pk, qk)
         S2 = stats.entropy(pk, qk, base=2.)
         xp_assert_less(xp.abs(S/S2 - math.log(2.)), xp.asarray(1.e-5))
 
-    @array_api_compatible
     def test_entropy_zero(self, xp):
         # Test for PR-479
         x = xp.asarray([0., 1., 2.])
         xp_assert_close(stats.entropy(x),
                         xp.asarray(0.63651416829481278))
 
-    @array_api_compatible
     def test_entropy_2d(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.2, 0.1], [0.3, 0.6], [0.5, 0.3]])
         xp_assert_close(stats.entropy(pk, qk),
                         xp.asarray([0.1933259, 0.18609809]))
 
-    @array_api_compatible
     def test_entropy_2d_zero(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.0, 0.1], [0.3, 0.6], [0.5, 0.3]])
@@ -59,20 +55,17 @@ class TestEntropy:
         xp_assert_close(stats.entropy(pk, qk),
                         xp.asarray([0.17403988, 0.18609809]))
 
-    @array_api_compatible
     def test_entropy_base_2d_nondefault_axis(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         xp_assert_close(stats.entropy(pk, axis=1),
                         xp.asarray([0.63651417, 0.63651417, 0.66156324]))
 
-    @array_api_compatible
     def test_entropy_2d_nondefault_axis(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.2, 0.1], [0.3, 0.6], [0.5, 0.3]])
         xp_assert_close(stats.entropy(pk, qk, axis=1),
                         xp.asarray([0.23104906, 0.23104906, 0.12770641]))
 
-    @array_api_compatible
     def test_entropy_raises_value_error(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.1, 0.2], [0.6, 0.3]])
@@ -80,33 +73,28 @@ class TestEntropy:
         with pytest.raises(ValueError, match=message):
             stats.entropy(pk, qk)
 
-    @array_api_compatible
     def test_base_entropy_with_axis_0_is_equal_to_default(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         xp_assert_close(stats.entropy(pk, axis=0),
                         stats.entropy(pk))
 
-    @array_api_compatible
     def test_entropy_with_axis_0_is_equal_to_default(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.2, 0.1], [0.3, 0.6], [0.5, 0.3]])
         xp_assert_close(stats.entropy(pk, qk, axis=0),
                         stats.entropy(pk, qk))
 
-    @array_api_compatible
     def test_base_entropy_transposed(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         xp_assert_close(stats.entropy(pk.T),
                         stats.entropy(pk, axis=1))
 
-    @array_api_compatible
     def test_entropy_transposed(self, xp):
         pk = xp.asarray([[0.1, 0.2], [0.6, 0.3], [0.3, 0.5]])
         qk = xp.asarray([[0.2, 0.1], [0.3, 0.6], [0.5, 0.3]])
         xp_assert_close(stats.entropy(pk.T, qk.T),
                         stats.entropy(pk, qk, axis=1))
 
-    @array_api_compatible
     def test_entropy_broadcasting(self, xp):
         rng = np.random.default_rng(74187315492831452)
         x = xp.asarray(rng.random(3))
@@ -115,7 +103,6 @@ class TestEntropy:
         xp_assert_equal(res[0], stats.entropy(x, y[0, ...]))
         xp_assert_equal(res[1], stats.entropy(x, y[1, ...]))
 
-    @array_api_compatible
     def test_entropy_shape_mismatch(self, xp):
         x = xp.ones((10, 1, 12))
         y = xp.ones((11, 2))
@@ -123,7 +110,6 @@ class TestEntropy:
         with pytest.raises(ValueError, match=message):
             stats.entropy(x, y)
 
-    @array_api_compatible
     def test_input_validation(self, xp):
         x = xp.ones(10)
         message = "`base` must be a positive number."
@@ -131,8 +117,7 @@ class TestEntropy:
             stats.entropy(x, base=-2)
 
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
+@pytest.mark.skip_xp_backends("dask.array", reason="boolean index assignment")
 class TestDifferentialEntropy:
     """
     Vasicek results are compared with the R package vsgoftest.
@@ -207,8 +192,6 @@ class TestDifferentialEntropy:
                     axis=1,
                 )
 
-    @pytest.mark.skip_xp_backends('jax.numpy',
-                                  reason="JAX doesn't support item assignment")
     def test_base_differential_entropy_with_axis_0_is_equal_to_default(self, xp):
         random_state = np.random.RandomState(0)
         values = random_state.standard_normal((100, 3))
@@ -218,8 +201,6 @@ class TestDifferentialEntropy:
         default_entropy = stats.differential_entropy(values)
         xp_assert_close(entropy, default_entropy)
 
-    @pytest.mark.skip_xp_backends('jax.numpy',
-                                  reason="JAX doesn't support item assignment")
     def test_base_differential_entropy_transposed(self, xp):
         random_state = np.random.RandomState(0)
         values = random_state.standard_normal((3, 100))
@@ -242,13 +223,17 @@ class TestDifferentialEntropy:
         with pytest.raises(ValueError, match=message):
             stats.differential_entropy(x, method='ekki-ekki')
 
-    @pytest.mark.parametrize('method', ['vasicek', 'van es',
-                                        'ebrahimi', 'correa'])
+    @pytest.mark.parametrize('method', [
+        'vasicek',
+        'van es',
+        'ebrahimi',
+        pytest.param(
+            'correa',
+            marks=skip_xp_backends("array_api_strict",
+                                   reason="Needs fancy indexing.")
+        )
+    ])
     def test_consistency(self, method, xp):
-        if is_jax(xp) and method == 'ebrahimi':
-            pytest.xfail("Needs array assignment.")
-        elif is_array_api_strict(xp) and method == 'correa':
-            pytest.xfail("Needs fancy indexing.")
         # test that method is a consistent estimator
         n = 10000 if method == 'correa' else 1000000
         rvs = stats.norm.rvs(size=n, random_state=0)
@@ -276,17 +261,21 @@ class TestDifferentialEntropy:
     rmse_std_cases = {norm: norm_rmse_std_cases,
                       expon: expon_rmse_std_cases}
 
-    @pytest.mark.parametrize('method', ['vasicek', 'van es', 'ebrahimi', 'correa'])
+    @pytest.mark.parametrize('method', [
+        'vasicek',
+        'van es',
+        'ebrahimi',
+        pytest.param(
+            'correa',
+            marks=skip_xp_backends("array_api_strict",
+                                   reason="Needs fancy indexing.")
+        )
+    ])
     @pytest.mark.parametrize('dist', [norm, expon])
     def test_rmse_std(self, method, dist, xp):
         # test that RMSE and standard deviation of estimators matches values
         # given in differential_entropy reference [6]. Incidentally, also
         # tests vectorization.
-        if is_jax(xp) and method == 'ebrahimi':
-            pytest.xfail("Needs array assignment.")
-        elif is_array_api_strict(xp) and method == 'correa':
-            pytest.xfail("Needs fancy indexing.")
-
         reps, n, m = 10000, 50, 7
         expected = self.rmse_std_cases[dist][method]
         rmse_expected, std_expected = xp.asarray(expected[0]), xp.asarray(expected[1])
@@ -297,31 +286,34 @@ class TestDifferentialEntropy:
                                          method=method, axis=-1)
         xp_assert_close(xp.sqrt(xp.mean((res - true_entropy)**2)),
                         rmse_expected, atol=0.005)
-        xp_test = array_namespace(res)
-        xp_assert_close(xp_test.std(res, correction=0), std_expected, atol=0.002)
+        xp_assert_close(xp.std(res, correction=0), std_expected, atol=0.002)
 
-    @pytest.mark.parametrize('n, method', [(8, 'van es'),
-                                           (12, 'ebrahimi'),
-                                           (1001, 'vasicek')])
+    @pytest.mark.parametrize('n, method', [
+        (8, 'van es'),
+        (12, 'ebrahimi'),
+        (1001, 'vasicek')
+    ])
     def test_method_auto(self, n, method, xp):
-        if is_jax(xp) and method == 'ebrahimi':
-            pytest.xfail("Needs array assignment.")
         rvs = stats.norm.rvs(size=(n,), random_state=0)
         rvs = xp.asarray(rvs.tolist())
         res1 = stats.differential_entropy(rvs)
         res2 = stats.differential_entropy(rvs, method=method)
         xp_assert_equal(res1, res2)
 
-    @pytest.mark.skip_xp_backends('jax.numpy',
-                                  reason="JAX doesn't support item assignment")
-    @pytest.mark.parametrize('method', ["vasicek", "van es", "correa", "ebrahimi"])
+    @pytest.mark.parametrize('method', [
+        "vasicek",
+        "van es",
+        pytest.param(
+            "correa",
+            marks=skip_xp_backends("array_api_strict", reason="Needs fancy indexing.")
+        ),
+        "ebrahimi"
+    ])
     @pytest.mark.parametrize('dtype', [None, 'float32', 'float64'])
     def test_dtypes_gh21192(self, xp, method, dtype):
         # gh-21192 noted a change in the output of method='ebrahimi'
         # with integer input. Check that the output is consistent regardless
         # of input dtype.
-        if is_array_api_strict(xp) and method == 'correa':
-            pytest.xfail("Needs fancy indexing.")
         x = [1, 1, 2, 3, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11]
         dtype_in = getattr(xp, str(dtype), None)
         dtype_out = getattr(xp, str(dtype), xp.asarray(1.).dtype)

scipy/stats/tests/test_fit.py

@@ -42,7 +42,8 @@ mle_failing_fits = [
 
 # these pass but are XSLOW (>1s)
 mle_Xslow_fits = ['betaprime', 'crystalball', 'exponweib', 'f', 'geninvgauss',
-                  'jf_skew_t', 'recipinvgauss', 'rel_breitwigner', 'vonmises_line']
+                  'jf_skew_t', 'nct', 'recipinvgauss', 'rel_breitwigner',
+                  'vonmises_line']
 
 # The MLE fit method of these distributions doesn't perform well when all
 # parameters are fit, so test them with the location fixed at 0.
@@ -129,10 +130,10 @@ def test_cont_fit(distname, arg, method):
 
     for fit_size in fit_sizes:
         # Note that if a fit succeeds, the other fit_sizes are skipped
-        np.random.seed(1234)
+        rng = np.random.default_rng(1234)
 
         with np.errstate(all='ignore'):
-            rvs = distfn.rvs(size=fit_size, *arg)
+            rvs = distfn.rvs(size=fit_size, *arg, random_state=rng)
             if method == 'MLE' and distfn.name in mle_use_floc0:
                 kwds = {'floc': 0}
             else:

scipy/stats/tests/test_hypotests.py

@@ -202,12 +202,12 @@ class TestMannWhitneyU:
     def test_auto(self):
         # Test that default method ('auto') chooses intended method
 
-        np.random.seed(1)
+        rng = np.random.RandomState(1)
         n = 8  # threshold to switch from exact to asymptotic
 
         # both inputs are smaller than threshold; should use exact
-        x = np.random.rand(n-1)
-        y = np.random.rand(n-1)
+        x = rng.rand(n-1)
+        y = rng.rand(n-1)
         auto = mannwhitneyu(x, y)
         asymptotic = mannwhitneyu(x, y, method='asymptotic')
         exact = mannwhitneyu(x, y, method='exact')
@@ -215,8 +215,8 @@ class TestMannWhitneyU:
         assert auto.pvalue != asymptotic.pvalue
 
         # one input is smaller than threshold; should use exact
-        x = np.random.rand(n-1)
-        y = np.random.rand(n+1)
+        x = rng.rand(n-1)
+        y = rng.rand(n+1)
         auto = mannwhitneyu(x, y)
         asymptotic = mannwhitneyu(x, y, method='asymptotic')
         exact = mannwhitneyu(x, y, method='exact')
@@ -231,8 +231,8 @@ class TestMannWhitneyU:
         assert auto.pvalue != asymptotic.pvalue
 
         # both inputs are larger than threshold; should use asymptotic
-        x = np.random.rand(n+1)
-        y = np.random.rand(n+1)
+        x = rng.rand(n+1)
+        y = rng.rand(n+1)
         auto = mannwhitneyu(x, y)
         asymptotic = mannwhitneyu(x, y, method='asymptotic')
         exact = mannwhitneyu(x, y, method='exact')
@@ -241,8 +241,8 @@ class TestMannWhitneyU:
 
         # both inputs are smaller than threshold, but there is a tie
         # should use asymptotic
-        x = np.random.rand(n-1)
-        y = np.random.rand(n-1)
+        x = rng.rand(n-1)
+        y = rng.rand(n-1)
         y[3] = x[3]
         auto = mannwhitneyu(x, y)
         asymptotic = mannwhitneyu(x, y, method='asymptotic')
@@ -394,19 +394,19 @@ class TestMannWhitneyU:
                 assert_allclose(pmf, pmf2)
 
     def test_asymptotic_behavior(self):
-        np.random.seed(0)
+        rng = np.random.default_rng(12543)
 
         # for small samples, the asymptotic test is not very accurate
-        x = np.random.rand(5)
-        y = np.random.rand(5)
+        x = rng.random(5)
+        y = rng.random(5)
         res1 = mannwhitneyu(x, y, method="exact")
         res2 = mannwhitneyu(x, y, method="asymptotic")
         assert res1.statistic == res2.statistic
         assert np.abs(res1.pvalue - res2.pvalue) > 1e-2
 
         # for large samples, they agree reasonably well
-        x = np.random.rand(40)
-        y = np.random.rand(40)
+        x = rng.random(40)
+        y = rng.random(40)
         res1 = mannwhitneyu(x, y, method="exact")
         res2 = mannwhitneyu(x, y, method="asymptotic")
         assert res1.statistic == res2.statistic
@@ -860,8 +860,9 @@ class TestSomersD(_TestPythranFunc):
         shape = 4, 6
         size = np.prod(shape)
 
-        np.random.seed(0)
-        s = stats.multinomial.rvs(N, p=np.ones(size)/size).reshape(shape)
+        rng = np.random.RandomState(0)
+        s = stats.multinomial.rvs(N, p=np.ones(size)/size,
+                                  random_state=rng).reshape(shape)
         res = stats.somersd(s)
 
         s2 = np.insert(s, 2, np.zeros(shape[1]), axis=0)
@@ -889,9 +890,10 @@ class TestSomersD(_TestPythranFunc):
         shape = 4, 6
         size = np.prod(shape)
 
-        np.random.seed(0)
+        rng = np.random.default_rng(0)
         # start with a valid contingency table
-        s = stats.multinomial.rvs(N, p=np.ones(size)/size).reshape(shape)
+        s = stats.multinomial.rvs(N, p=np.ones(size)/size,
+                                  random_state=rng).reshape(shape)
 
         s5 = s - 2
         message = "All elements of the contingency table must be non-negative"
@@ -1003,6 +1005,7 @@ class TestSomersD(_TestPythranFunc):
         assert res.statistic == expected_statistic
         assert res.pvalue == (0 if positive_correlation else 1)
 
+    @pytest.mark.thread_unsafe
     def test_somersd_large_inputs_gh18132(self):
         # Test that large inputs where potential overflows could occur give
         # the expected output. This is tested in the case of binary inputs.
@@ -1375,18 +1378,18 @@ class TestCvm_2samp:
     def test_large_sample(self):
         # for large samples, the statistic U gets very large
         # do a sanity check that p-value is not 0, 1 or nan
-        np.random.seed(4367)
-        x = distributions.norm.rvs(size=1000000)
-        y = distributions.norm.rvs(size=900000)
+        rng = np.random.default_rng(4367)
+        x = distributions.norm.rvs(size=1000000, random_state=rng)
+        y = distributions.norm.rvs(size=900000, random_state=rng)
         r = cramervonmises_2samp(x, y)
         assert_(0 < r.pvalue < 1)
         r = cramervonmises_2samp(x, y+0.1)
         assert_(0 < r.pvalue < 1)
 
     def test_exact_vs_asymptotic(self):
-        np.random.seed(0)
-        x = np.random.rand(7)
-        y = np.random.rand(8)
+        rng = np.random.RandomState(0)
+        x = rng.rand(7)
+        y = rng.rand(8)
         r1 = cramervonmises_2samp(x, y, method='exact')
         r2 = cramervonmises_2samp(x, y, method='asymptotic')
         assert_equal(r1.statistic, r2.statistic)
@@ -1640,6 +1643,11 @@ class TestTukeyHSD:
         with assert_raises(ValueError, match="...must be greater than one"):
             stats.tukey_hsd([], [2, 5], [4, 5, 6])
 
+    def test_equal_var_input_validation(self):
+        msg = "Expected a boolean value for 'equal_var'"
+        with assert_raises(TypeError, match=msg):
+            stats.tukey_hsd([1, 2, 3], [2, 5], [6, 7], equal_var="False")
+
     @pytest.mark.parametrize("nargs", (0, 1))
     def test_not_enough_treatments(self, nargs):
         with assert_raises(ValueError, match="...more than 1 treatment."):
@@ -1659,6 +1667,127 @@ class TestTukeyHSD:
         assert_allclose(res_ttest.pvalue, res_tukey.pvalue[1, 0])
 
 
+class TestGamesHowell:
+    # data with unequal variances
+    data_same_size = ([24., 23., 31., 51.],
+                      [34., 18., 18., 26.],
+                      [17., 68., 59.,  7.])
+
+    data_diff_size = ([30., 23., 51.],
+                      [-81., 71., -27., 63.],
+                      [42., 11., 29., 19., 50.],
+                      [23., 22., 20., 18., 9.])
+
+    spss_same_size = """
+            Mean Diff      Lower Bound         Upper Bound         Sig
+    0 - 1   8.25000000    -16.5492749527311    33.0492749527311    0.558733632413559
+    0 - 2  -5.50000000    -63.6702454316458    52.6702454316458    0.941147750599221
+    1 - 2  -13.7500000    -74.3174374251372    46.8174374251372    0.682983914946841
+    """
+
+    spss_diff_size = """
+             Mean Diff       Lower Bound        Upper Bound         Sig
+    0 - 1	 28.16666667    -141.985416377670   198.318749711003	0.8727542747886180
+    0 - 2	 4.466666667	-37.2830676783904   46.2164010117237	0.9752628408671710
+    0 - 3	 16.26666667	-35.0933112382470   67.6266445715803	0.4262506151302880
+    1 - 2	-23.70000000	-195.315617201249   147.915617201249	0.9148950609000590
+    1 - 3	-11.90000000	-188.105478728519   164.305478728519	0.9861432250093960
+    2 - 3	 11.80000000	-16.2894857524254	39.8894857524254    0.4755344436335670
+    """
+
+    @pytest.mark.xslow
+    @pytest.mark.parametrize("data, res_expect_str",
+                            ((data_same_size, spss_same_size),
+                            (data_diff_size, spss_diff_size)),
+                            ids=["equal size sample",
+                                 "unequal sample size"])
+    def test_compare_spss(self, data, res_expect_str):
+        """
+        DATA LIST LIST /Group (F1.0) Value (F8.2).
+        BEGIN DATA
+        0 24
+        0 23
+        0 31
+        0 51
+        1 34
+        1 18
+        1 18
+        1 26
+        2 17
+        2 68
+        2 59
+        2 7
+        END DATA.
+
+        ONEWAY Value BY Group
+            /MISSING ANALYSIS
+            /POSTHOC=GH ALPHA(0.05).
+        """
+        res_expect = np.asarray(
+            res_expect_str.replace(" - ", " ").split()[7:],
+            dtype=float).reshape(-1, 6)
+        res_games = stats.tukey_hsd(*data, equal_var=False)
+        conf = res_games.confidence_interval()
+        # loop over the comparisons
+        for i, j, s, l, h, p in res_expect:
+            i, j = int(i), int(j)
+            assert_allclose(res_games.statistic[i, j], s, atol=1e-8)
+            assert_allclose(res_games.pvalue[i, j], p, atol=1e-8)
+            assert_allclose(conf.low[i, j], l, atol=1e-6)
+            assert_allclose(conf.high[i, j], h, atol=1e-5)
+
+    r_same_size = """
+                  q value             Pr(>|q|)
+    1 - 0 == 0   -1.5467805948856344  0.55873362851759
+    2 - 0 == 0    0.4726721776628535  0.94114775035993
+    2 - 1 == 0    1.246837541297872   0.68298393799782
+    """
+
+    r_diff_size = """
+                 q value             Pr(>|q|)
+    1 - 0 == 0  -1.0589317485313876  0.87275427357438
+    2 - 0 == 0  -0.5716222106144833  0.97526284087419
+    3 - 0 == 0  -2.6209678382077000  0.42625067714691
+    2 - 1 == 0   0.8971899898179028  0.91489506061850
+    3 - 1 == 0   0.4579447210555352  0.98614322544695
+    3 - 2 == 0  -2.198800177874794   0.47553444364614
+    """
+
+    @pytest.mark.parametrize("data, res_expect_str",
+                            ((data_same_size, r_same_size),
+                            (data_diff_size, r_diff_size)),
+                            ids=["equal size sample",
+                                 "unequal sample size"])
+    def test_compare_r(self, data, res_expect_str):
+        """
+        games-howell is provided by PMCMRplus package
+        https://search.r-project.org/CRAN/refmans/PMCMRplus/html/gamesHowellTest.html
+        > library("PMCMRplus")
+        > options(digits=16)
+        > table = data.frame(
+            values = c(24., 23., 31., 51., 34., 18., 18., 26., 17., 68., 59.,  7.),
+            groups = c("0", "0", "0", "0", "1", "1", "1", "1", "2", "2", "2", "2")
+          )
+        > table$groups = as.factor(table$groups)
+        > fit <-aov(values ~ groups, table)
+        > res = gamesHowellTest(fit)
+        > summary(res)
+        """
+        res_expect = np.asarray(
+            res_expect_str.replace(" - ", " ")
+            .replace(" == ", " ").split()[3:],
+            dtype=float).reshape(-1, 5)
+        res_games = stats.tukey_hsd(*data, equal_var=False)
+        # loop over the comparisons
+        # note confidence intervals are not provided by PMCMRplus
+        for j, i, _, _, p in res_expect:
+            i, j = int(i), int(j)
+            assert_allclose(res_games.pvalue[i, j], p, atol=1e-7)
+
+    # Data validation test has been covered by TestTukeyHSD
+    # like empty, 1d, inf, and lack of tretments
+    # because games_howell leverage _tukey_hsd_iv()
+
 class TestPoissonMeansTest:
     @pytest.mark.parametrize("c1, n1, c2, n2, p_expect", (
         # example from [1], 6. Illustrative examples: Example 1