From 9f9a64327a9cff6dd9ba0642500745691c631eb7 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Sat, 23 Dec 2023 15:08:26 -0800
Subject: [PATCH 01/12] Remove conftest in indexing

---
 pandas/tests/indexing/conftest.py    | 127 --------------------------
 pandas/tests/indexing/test_iloc.py   |  15 ++-
 pandas/tests/indexing/test_loc.py    | 131 +++++++++++++--------------
 pandas/tests/indexing/test_scalar.py |  38 +++++---
 4 files changed, 99 insertions(+), 212 deletions(-)
 delete mode 100644 pandas/tests/indexing/conftest.py

diff --git a/pandas/tests/indexing/conftest.py b/pandas/tests/indexing/conftest.py
deleted file mode 100644
index 4184c6a0047cc..0000000000000
--- a/pandas/tests/indexing/conftest.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import (
-    DataFrame,
-    Index,
-    MultiIndex,
-    Series,
-    date_range,
-)
-
-
-@pytest.fixture
-def series_ints():
-    return Series(np.random.default_rng(2).random(4), index=np.arange(0, 8, 2))
-
-
-@pytest.fixture
-def frame_ints():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=np.arange(0, 8, 2),
-        columns=np.arange(0, 12, 3),
-    )
-
-
-@pytest.fixture
-def series_uints():
-    return Series(
-        np.random.default_rng(2).random(4),
-        index=Index(np.arange(0, 8, 2, dtype=np.uint64)),
-    )
-
-
-@pytest.fixture
-def frame_uints():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=Index(range(0, 8, 2), dtype=np.uint64),
-        columns=Index(range(0, 12, 3), dtype=np.uint64),
-    )
-
-
-@pytest.fixture
-def series_labels():
-    return Series(np.random.default_rng(2).standard_normal(4), index=list("abcd"))
-
-
-@pytest.fixture
-def frame_labels():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=list("abcd"),
-        columns=list("ABCD"),
-    )
-
-
-@pytest.fixture
-def series_ts():
-    return Series(
-        np.random.default_rng(2).standard_normal(4),
-        index=date_range("20130101", periods=4),
-    )
-
-
-@pytest.fixture
-def frame_ts():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=date_range("20130101", periods=4),
-    )
-
-
-@pytest.fixture
-def series_floats():
-    return Series(
-        np.random.default_rng(2).random(4),
-        index=Index(range(0, 8, 2), dtype=np.float64),
-    )
-
-
-@pytest.fixture
-def frame_floats():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=Index(range(0, 8, 2), dtype=np.float64),
-        columns=Index(range(0, 12, 3), dtype=np.float64),
-    )
-
-
-@pytest.fixture
-def series_mixed():
-    return Series(np.random.default_rng(2).standard_normal(4), index=[2, 4, "null", 8])
-
-
-@pytest.fixture
-def frame_mixed():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)), index=[2, 4, "null", 8]
-    )
-
-
-@pytest.fixture
-def frame_empty():
-    return DataFrame()
-
-
-@pytest.fixture
-def series_empty():
-    return Series(dtype=object)
-
-
-@pytest.fixture
-def frame_multi():
-    return DataFrame(
-        np.random.default_rng(2).standard_normal((4, 4)),
-        index=MultiIndex.from_product([[1, 2], [3, 4]]),
-        columns=MultiIndex.from_product([[5, 6], [7, 8]]),
-    )
-
-
-@pytest.fixture
-def series_multi():
-    return Series(
-        np.random.default_rng(2).random(4),
-        index=MultiIndex.from_product([[1, 2], [3, 4]]),
-    )
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 409eca42f404b..36f00a3ce7cd7 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -39,13 +39,18 @@
 
 class TestiLoc:
     @pytest.mark.parametrize("key", [2, -1, [0, 1, 2]])
-    @pytest.mark.parametrize("kind", ["series", "frame"])
     @pytest.mark.parametrize(
-        "col",
-        ["labels", "mixed", "ts", "floats", "empty"],
+        "index",
+        [
+            Index(list("abcd"), dtype=object),
+            Index([2, 4, "null", 8], dtype=object),
+            date_range("20130101", periods=4),
+            Index(range(0, 8, 2), dtype=np.float64),
+            Index([]),
+        ],
     )
-    def test_iloc_getitem_int_and_list_int(self, key, kind, col, request):
-        obj = request.getfixturevalue(f"{kind}_{col}")
+    def test_iloc_getitem_int_and_list_int(self, key, frame_or_series, index, request):
+        obj = frame_or_series(range(len(index)), index=index)
         check_indexing_smoketest_or_raises(
             obj,
             "iloc",
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index fb0adc56c401b..60fa319001c3b 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -69,116 +69,111 @@ def test_none_values_on_string_columns(self):
 
         assert df.loc[2, "a"] is None
 
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_int(self, kind, request):
+    def test_loc_getitem_int(self, frame_or_series):
         # int label
-        obj = request.getfixturevalue(f"{kind}_labels")
+        obj = frame_or_series(range(3), index=Index(list("abc"), dtype=object))
         check_indexing_smoketest_or_raises(obj, "loc", 2, fails=KeyError)
 
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label(self, kind, request):
+    def test_loc_getitem_label(self, frame_or_series):
         # label
-        obj = request.getfixturevalue(f"{kind}_empty")
+        obj = frame_or_series()
         check_indexing_smoketest_or_raises(obj, "loc", "c", fails=KeyError)
 
+    @pytest.mark.parametrize("key", ["f", 20])
     @pytest.mark.parametrize(
-        "key, typs, axes",
+        "index",
         [
-            ["f", ["ints", "uints", "labels", "mixed", "ts"], None],
-            ["f", ["floats"], None],
-            [20, ["ints", "uints", "mixed"], None],
-            [20, ["labels"], None],
-            [20, ["ts"], 0],
-            [20, ["floats"], 0],
+            Index(list("abcd"), dtype=object),
+            Index([2, 4, "null", 8], dtype=object),
+            date_range("20130101", periods=4),
+            Index(range(0, 8, 2), dtype=np.float64),
+            Index([]),
         ],
     )
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label_out_of_range(self, key, typs, axes, kind, request):
-        for typ in typs:
-            obj = request.getfixturevalue(f"{kind}_{typ}")
-            # out of range label
-            check_indexing_smoketest_or_raises(
-                obj, "loc", key, axes=axes, fails=KeyError
-            )
+    def test_loc_getitem_label_out_of_range(self, key, index, frame_or_series):
+        obj = frame_or_series(range(len(index)), index=index)
+        # out of range label
+        check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
+
+    @pytest.mark.parametrize("key", [[0, 1, 2], [1, 3.0, "A"]])
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64, np.float64])
+    def test_loc_getitem_label_list(self, key, dtype, frame_or_series):
+        obj = frame_or_series(range(3), index=Index([0, 1, 2], dtype=dtype))
+        # list of labels
+        check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
 
     @pytest.mark.parametrize(
-        "key, typs",
+        "index",
         [
-            [[0, 1, 2], ["ints", "uints", "floats"]],
-            [[1, 3.0, "A"], ["ints", "uints", "floats"]],
+            None,
+            Index([0, 1, 2], dtype=np.int64),
+            Index([0, 1, 2], dtype=np.uint64),
+            Index([0, 1, 2], dtype=np.float64),
+            MultiIndex.from_arrays([range(3), range(3)]),
         ],
     )
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label_list(self, key, typs, kind, request):
-        for typ in typs:
-            obj = request.getfixturevalue(f"{kind}_{typ}")
-            # list of labels
-            check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
-
     @pytest.mark.parametrize(
-        "key, typs, axes",
-        [
-            [[0, 1, 2], ["empty"], None],
-            [[0, 2, 10], ["ints", "uints", "floats"], 0],
-            [[3, 6, 7], ["ints", "uints", "floats"], 1],
-            # GH 17758 - MultiIndex and missing keys
-            [[(1, 3), (1, 4), (2, 5)], ["multi"], 0],
-        ],
+        "key", [[0, 1, 2], [0, 2, 10], [3, 6, 7], [(1, 3), (1, 4), (2, 5)]]
     )
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label_list_with_missing(self, key, typs, axes, kind, request):
-        for typ in typs:
-            obj = request.getfixturevalue(f"{kind}_{typ}")
-            check_indexing_smoketest_or_raises(
-                obj, "loc", key, axes=axes, fails=KeyError
-            )
+    def test_loc_getitem_label_list_with_missing(self, key, index, frame_or_series):
+        if index is None:
+            obj = frame_or_series()
+        else:
+            obj = frame_or_series(range(len(index)), index=index)
+        check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
 
-    @pytest.mark.parametrize("typs", ["ints", "uints"])
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label_list_fails(self, typs, kind, request):
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+    def test_loc_getitem_label_list_fails(self, dtype, frame_or_series):
         # fails
-        obj = request.getfixturevalue(f"{kind}_{typs}")
+        obj = frame_or_series(range(3), Index([0, 1, 2], dtype=dtype))
         check_indexing_smoketest_or_raises(
             obj, "loc", [20, 30, 40], axes=1, fails=KeyError
         )
 
-    def test_loc_getitem_label_array_like(self):
-        # TODO: test something?
-        # array like
-        pass
-
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_bool(self, kind, request):
-        obj = request.getfixturevalue(f"{kind}_empty")
+    def test_loc_getitem_bool(self, frame_or_series):
+        obj = frame_or_series()
         # boolean indexers
         b = [True, False, True, False]
 
         check_indexing_smoketest_or_raises(obj, "loc", b, fails=IndexError)
 
     @pytest.mark.parametrize(
-        "slc, typs, axes, fails",
+        "slc, indexes, axes, fails",
         [
             [
                 slice(1, 3),
-                ["labels", "mixed", "empty", "ts", "floats"],
+                [
+                    Index(list("abcd"), dtype=object),
+                    Index([2, 4, "null", 8], dtype=object),
+                    None,
+                    date_range("20130101", periods=4),
+                    Index(range(0, 12, 3), dtype=np.float64),
+                ],
                 None,
                 TypeError,
             ],
-            [slice("20130102", "20130104"), ["ts"], 1, TypeError],
-            [slice(2, 8), ["mixed"], 0, TypeError],
-            [slice(2, 8), ["mixed"], 1, KeyError],
-            [slice(2, 4, 2), ["mixed"], 0, TypeError],
+            [
+                slice("20130102", "20130104"),
+                [date_range("20130101", periods=4)],
+                1,
+                TypeError,
+            ],
+            [slice(2, 8), [Index([2, 4, "null", 8], dtype=object)], 0, TypeError],
+            [slice(2, 8), [Index([2, 4, "null", 8], dtype=object)], 1, KeyError],
+            [slice(2, 4, 2), [Index([2, 4, "null", 8], dtype=object)], 0, TypeError],
         ],
     )
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    def test_loc_getitem_label_slice(self, slc, typs, axes, fails, kind, request):
+    def test_loc_getitem_label_slice(self, slc, indexes, axes, fails, frame_or_series):
         # label slices (with ints)
 
         # real label slices
 
         # GH 14316
-        for typ in typs:
-            obj = request.getfixturevalue(f"{kind}_{typ}")
+        for index in indexes:
+            if index is None:
+                obj = frame_or_series()
+            else:
+                obj = frame_or_series(range(len(index)), index=index)
             check_indexing_smoketest_or_raises(
                 obj,
                 "loc",
diff --git a/pandas/tests/indexing/test_scalar.py b/pandas/tests/indexing/test_scalar.py
index 29e3dc0aebe95..ef4cd402aaf24 100644
--- a/pandas/tests/indexing/test_scalar.py
+++ b/pandas/tests/indexing/test_scalar.py
@@ -10,6 +10,7 @@
 
 from pandas import (
     DataFrame,
+    Index,
     Series,
     Timedelta,
     Timestamp,
@@ -32,29 +33,42 @@ def generate_indices(f, values=False):
 
 
 class TestScalar:
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    @pytest.mark.parametrize("col", ["ints", "uints"])
-    def test_iat_set_ints(self, kind, col, request):
-        f = request.getfixturevalue(f"{kind}_{col}")
+    @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+    def test_iat_set_ints(self, dtype, frame_or_series):
+        f = frame_or_series(range(3), index=Index([0, 1, 2], dtype=dtype))
         indices = generate_indices(f, True)
         for i in indices:
             f.iat[i] = 1
             expected = f.values[i]
             tm.assert_almost_equal(expected, 1)
 
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    @pytest.mark.parametrize("col", ["labels", "ts", "floats"])
-    def test_iat_set_other(self, kind, col, request):
-        f = request.getfixturevalue(f"{kind}_{col}")
+    @pytest.mark.parametrize(
+        "index",
+        [
+            Index(list("abcd"), dtype=object),
+            date_range("20130101", periods=4),
+            Index(range(0, 8, 2), dtype=np.float64),
+        ],
+    )
+    def test_iat_set_other(self, index, frame_or_series):
+        f = frame_or_series(range(len(index)), index=index)
         msg = "iAt based indexing can only have integer indexers"
         with pytest.raises(ValueError, match=msg):
             idx = next(generate_indices(f, False))
             f.iat[idx] = 1
 
-    @pytest.mark.parametrize("kind", ["series", "frame"])
-    @pytest.mark.parametrize("col", ["ints", "uints", "labels", "ts", "floats"])
-    def test_at_set_ints_other(self, kind, col, request):
-        f = request.getfixturevalue(f"{kind}_{col}")
+    @pytest.mark.parametrize(
+        "index",
+        [
+            Index(list("abcd"), dtype=object),
+            date_range("20130101", periods=4),
+            Index(range(0, 8, 2), dtype=np.float64),
+            Index(range(0, 8, 2), dtype=np.uint64),
+            Index(range(0, 8, 2), dtype=np.int64),
+        ],
+    )
+    def test_at_set_ints_other(self, index, frame_or_series):
+        f = frame_or_series(range(len(index)), index=index)
         indices = generate_indices(f, False)
         for i in indices:
             f.at[i] = 1

From e4f81bb3aff832bc1f23a109624b792e5f08f6e2 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Sat, 23 Dec 2023 17:42:25 -0800
Subject: [PATCH 02/12] Use less idx fixture in multi

---
 pandas/tests/indexes/multi/test_analytics.py  | 17 +++++----
 pandas/tests/indexes/multi/test_astype.py     |  7 ++--
 pandas/tests/indexes/multi/test_compat.py     |  6 ++--
 .../tests/indexes/multi/test_constructors.py  |  3 +-
 pandas/tests/indexes/multi/test_conversion.py |  3 +-
 pandas/tests/indexes/multi/test_copy.py       |  9 +++--
 pandas/tests/indexes/multi/test_duplicates.py | 10 ++++--
 .../tests/indexes/multi/test_equivalence.py   | 21 ++++++-----
 pandas/tests/indexes/multi/test_formats.py    |  6 ++--
 pandas/tests/indexes/multi/test_get_set.py    |  3 +-
 pandas/tests/indexes/multi/test_integrity.py  | 17 +++++----
 pandas/tests/indexes/multi/test_join.py       |  3 +-
 pandas/tests/indexes/multi/test_missing.py    | 10 +++---
 pandas/tests/indexes/multi/test_reindex.py    | 10 ++++--
 pandas/tests/indexes/multi/test_reshape.py    | 18 +++++++---
 pandas/tests/indexes/multi/test_setops.py     | 36 +++++++++++++------
 pandas/tests/indexes/multi/test_sorting.py    | 31 ++++------------
 pandas/tests/indexes/multi/test_take.py       |  6 +++-
 18 files changed, 133 insertions(+), 83 deletions(-)

diff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py
index 87f1439db5fc8..a0e7510fbe2dc 100644
--- a/pandas/tests/indexes/multi/test_analytics.py
+++ b/pandas/tests/indexes/multi/test_analytics.py
@@ -11,13 +11,15 @@
 import pandas._testing as tm
 
 
-def test_infer_objects(idx):
+def test_infer_objects():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with pytest.raises(NotImplementedError, match="to_frame"):
         idx.infer_objects()
 
 
-def test_shift(idx):
+def test_shift():
     # GH8083 test the base class for shift
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = (
         "This method is only implemented for DatetimeIndex, PeriodIndex and "
         "TimedeltaIndex; Got type MultiIndex"
@@ -76,8 +78,9 @@ def test_truncate_multiindex():
 # TODO: reshape
 
 
-def test_reorder_levels(idx):
+def test_reorder_levels():
     # this blows up
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with pytest.raises(IndexError, match="^Too many levels"):
         idx.reorder_levels([2, 1, 0])
 
@@ -174,9 +177,9 @@ def test_sub(idx):
         first.tolist() - idx[-3:]
 
 
-def test_map(idx):
+def test_map():
     # callable
-    index = idx
+    index = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
 
     result = index.map(lambda x: x)
     tm.assert_index_equal(result, index)
@@ -235,10 +238,11 @@ def test_map_dictlike(idx, mapper):
     ],
     ids=lambda func: func.__name__,
 )
-def test_numpy_ufuncs(idx, func):
+def test_numpy_ufuncs(func):
     # test ufuncs of numpy. see:
     # https://numpy.org/doc/stable/reference/ufuncs.html
 
+    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     expected_exception = TypeError
     msg = (
         "loop of ufunc does not support argument 0 of type tuple which "
@@ -254,6 +258,7 @@ def test_numpy_ufuncs(idx, func):
     ids=lambda func: func.__name__,
 )
 def test_numpy_type_funcs(idx, func):
+    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     msg = (
         f"ufunc '{func.__name__}' not supported for the input types, and the inputs "
         "could not be safely coerced to any supported types according to "
diff --git a/pandas/tests/indexes/multi/test_astype.py b/pandas/tests/indexes/multi/test_astype.py
index 29908537fbe59..1f9f8d91ad970 100644
--- a/pandas/tests/indexes/multi/test_astype.py
+++ b/pandas/tests/indexes/multi/test_astype.py
@@ -3,10 +3,12 @@
 
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
+from pandas import MultiIndex
 import pandas._testing as tm
 
 
-def test_astype(idx):
+def test_astype():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]], names=["foo"])
     expected = idx.copy()
     actual = idx.astype("O")
     tm.assert_copy(actual.levels, expected.levels)
@@ -18,7 +20,8 @@ def test_astype(idx):
 
 
 @pytest.mark.parametrize("ordered", [True, False])
-def test_astype_category(idx, ordered):
+def test_astype_category(ordered):
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     # GH 18630
     msg = "> 1 ndim Categorical are not supported at this time"
     with pytest.raises(NotImplementedError, match=msg):
diff --git a/pandas/tests/indexes/multi/test_compat.py b/pandas/tests/indexes/multi/test_compat.py
index 27a8c6e9b7158..4bc73f8272d08 100644
--- a/pandas/tests/indexes/multi/test_compat.py
+++ b/pandas/tests/indexes/multi/test_compat.py
@@ -6,7 +6,8 @@
 import pandas._testing as tm
 
 
-def test_numeric_compat(idx):
+def test_numeric_compat():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with pytest.raises(TypeError, match="cannot perform __mul__"):
         idx * 1
 
@@ -29,7 +30,8 @@ def test_numeric_compat(idx):
 
 
 @pytest.mark.parametrize("method", ["all", "any", "__invert__"])
-def test_logical_compat(idx, method):
+def test_logical_compat(method):
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = f"cannot perform {method}"
 
     with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 8456e6a7acba5..0ad8831805087 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -385,7 +385,8 @@ def test_from_tuples_empty():
     tm.assert_index_equal(result, expected)
 
 
-def test_from_tuples_index_values(idx):
+def test_from_tuples_index_values():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = MultiIndex.from_tuples(idx)
     assert (result.values == idx.values).all()
 
diff --git a/pandas/tests/indexes/multi/test_conversion.py b/pandas/tests/indexes/multi/test_conversion.py
index 3c2ca045d6f99..0109d67cb7dde 100644
--- a/pandas/tests/indexes/multi/test_conversion.py
+++ b/pandas/tests/indexes/multi/test_conversion.py
@@ -9,7 +9,8 @@
 import pandas._testing as tm
 
 
-def test_to_numpy(idx):
+def test_to_numpy():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = idx.to_numpy()
     exp = idx.values
     tm.assert_numpy_array_equal(result, exp)
diff --git a/pandas/tests/indexes/multi/test_copy.py b/pandas/tests/indexes/multi/test_copy.py
index 2e09a580f9528..504496ea527cc 100644
--- a/pandas/tests/indexes/multi/test_copy.py
+++ b/pandas/tests/indexes/multi/test_copy.py
@@ -26,19 +26,22 @@ def assert_multiindex_copied(copy, original):
     assert copy.sortorder == original.sortorder
 
 
-def test_copy(idx):
+def test_copy():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     i_copy = idx.copy()
 
     assert_multiindex_copied(i_copy, idx)
 
 
-def test_shallow_copy(idx):
+def test_shallow_copy():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     i_copy = idx._view()
 
     assert_multiindex_copied(i_copy, idx)
 
 
-def test_view(idx):
+def test_view():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     i_view = idx.view()
     assert_multiindex_copied(i_view, idx)
 
diff --git a/pandas/tests/indexes/multi/test_duplicates.py b/pandas/tests/indexes/multi/test_duplicates.py
index 6c6d9022b1af3..faf83407cfa50 100644
--- a/pandas/tests/indexes/multi/test_duplicates.py
+++ b/pandas/tests/indexes/multi/test_duplicates.py
@@ -145,13 +145,19 @@ def test_duplicate_meta_data():
         assert idx.drop_duplicates().names == idx.names
 
 
-def test_has_duplicates(idx, idx_dup):
-    # see fixtures
+def test_has_duplicates():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert idx.is_unique is True
     assert idx.has_duplicates is False
+
+
+def test_has_duplicates_with_dups(idx_dup):
+    # see fixtures
     assert idx_dup.is_unique is False
     assert idx_dup.has_duplicates is True
 
+
+def test_has_duplicates_other():
     mi = MultiIndex(
         levels=[[0, 1], [0, 1, 2]], codes=[[0, 0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 0, 1, 2]]
     )
diff --git a/pandas/tests/indexes/multi/test_equivalence.py b/pandas/tests/indexes/multi/test_equivalence.py
index 9babbd5b8d56d..079f6194c2ff9 100644
--- a/pandas/tests/indexes/multi/test_equivalence.py
+++ b/pandas/tests/indexes/multi/test_equivalence.py
@@ -12,7 +12,8 @@
 import pandas._testing as tm
 
 
-def test_equals(idx):
+def test_equals():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert idx.equals(idx)
     assert idx.equals(idx.copy())
     assert idx.equals(idx.astype(object))
@@ -26,10 +27,6 @@ def test_equals(idx):
     assert idx.equals(same_values)
     assert same_values.equals(idx)
 
-    if idx.nlevels == 1:
-        # do not test MultiIndex
-        assert not idx.equals(Series(idx))
-
 
 def test_equals_op(idx):
     # GH9947, GH10637
@@ -132,7 +129,8 @@ def test_compare_tuple_strs():
     tm.assert_numpy_array_equal(result, expected)
 
 
-def test_equals_multi(idx):
+def test_equals_multi():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert idx.equals(idx)
     assert not idx.equals(idx.values)
     assert idx.equals(Index(idx.values))
@@ -141,6 +139,8 @@ def test_equals_multi(idx):
     assert not idx.equals(idx[:-1])
     assert not idx.equals(idx[-1])
 
+
+def test_equals_multi_different_levels(idx):
     # different number of levels
     index = MultiIndex(
         levels=[Index(list(range(4))), Index(list(range(4))), Index(list(range(4)))],
@@ -181,7 +181,8 @@ def test_equals_multi(idx):
     assert not idx.equals(index)
 
 
-def test_identical(idx):
+def test_identical():
+    idx = MultiIndex(levels=[[0, 1], [2, 3]], codes=[[0, 1], [0, 1]])
     mi = idx.copy()
     mi2 = idx.copy()
     assert mi.identical(mi2)
@@ -249,12 +250,14 @@ def test_is_():
     assert not mi5.is_(mi)
 
 
-def test_is_all_dates(idx):
+def test_is_all_dates():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert not idx._is_all_dates
 
 
-def test_is_numeric(idx):
+def test_is_numeric():
     # MultiIndex is never numeric
+    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     assert not is_any_real_numeric_dtype(idx)
 
 
diff --git a/pandas/tests/indexes/multi/test_formats.py b/pandas/tests/indexes/multi/test_formats.py
index 52ff3109128f2..b3988e824775b 100644
--- a/pandas/tests/indexes/multi/test_formats.py
+++ b/pandas/tests/indexes/multi/test_formats.py
@@ -9,8 +9,9 @@
 import pandas._testing as tm
 
 
-def test_format(idx):
+def test_format():
     msg = "MultiIndex.format is deprecated"
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with tm.assert_produces_warning(FutureWarning, match=msg):
         idx.format()
         idx[:0].format()
@@ -70,8 +71,9 @@ def test_unicode_string_with_unicode():
     str(idx)
 
 
-def test_repr_max_seq_item_setting(idx):
+def test_repr_max_seq_item_setting():
     # GH10182
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     idx = idx.repeat(50)
     with pd.option_context("display.max_seq_items", None):
         repr(idx)
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index 6eeaeb6711d03..969cbf6fb8cd9 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -242,7 +242,8 @@ def test_set_codes(idx):
     assert result.equals(expected)
 
 
-def test_set_levels_codes_names_bad_input(idx):
+def test_set_levels_codes_names_bad_input():
+    idx = MultiIndex(levels=[["A", "B"], ["B", "C"]], codes=[[0, 1], [0, 1]])
     levels, codes = idx.levels, idx.codes
     names = idx.names
 
diff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py
index d956747cbc859..93262da50b0f6 100644
--- a/pandas/tests/indexes/multi/test_integrity.py
+++ b/pandas/tests/indexes/multi/test_integrity.py
@@ -163,10 +163,11 @@ def test_take_invalid_kwargs():
         idx.take(indices, mode="clip")
 
 
-def test_isna_behavior(idx):
+def test_isna_behavior():
     # should not segfault GH5123
     # NOTE: if MI representation changes, may make sense to allow
     # isna(MI)
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         pd.isna(idx)
@@ -208,12 +209,14 @@ def test_mi_hashtable_populated_attribute_error(monkeypatch):
         df["a"].foo()
 
 
-def test_can_hold_identifiers(idx):
+def test_can_hold_identifiers():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     key = idx[0]
     assert idx._can_hold_identifiers_and_holds_name(key) is True
 
 
-def test_metadata_immutable(idx):
+def test_metadata_immutable():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     levels, codes = idx.levels, idx.codes
     # shouldn't be able to set at either the top level or base level
     mutable_regex = re.compile("does not support mutable operations")
@@ -265,7 +268,8 @@ def test_rangeindex_fallback_coercion_bug():
     tm.assert_index_equal(result, expected)
 
 
-def test_memory_usage(idx):
+def test_memory_usage():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = idx.memory_usage()
     if len(idx):
         idx.get_loc(idx[0])
@@ -285,5 +289,6 @@ def test_memory_usage(idx):
         assert result == 0
 
 
-def test_nlevels(idx):
-    assert idx.nlevels == 2
+def test_nlevels():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+    assert idx.nlevels == 1
diff --git a/pandas/tests/indexes/multi/test_join.py b/pandas/tests/indexes/multi/test_join.py
index edd0feaaa1159..1b88ef790723c 100644
--- a/pandas/tests/indexes/multi/test_join.py
+++ b/pandas/tests/indexes/multi/test_join.py
@@ -50,7 +50,8 @@ def test_join_level_corner_case(idx):
         idx.join(idx, level=1)
 
 
-def test_join_self(idx, join_type):
+def test_join_self(join_type):
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = idx.join(idx, how=join_type)
     expected = idx
     if join_type == "outer":
diff --git a/pandas/tests/indexes/multi/test_missing.py b/pandas/tests/indexes/multi/test_missing.py
index 14ffc42fb4b59..5e3c545f6a35f 100644
--- a/pandas/tests/indexes/multi/test_missing.py
+++ b/pandas/tests/indexes/multi/test_missing.py
@@ -6,8 +6,9 @@
 import pandas._testing as tm
 
 
-def test_fillna(idx):
+def test_fillna():
     # GH 11343
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         idx.fillna(idx[0])
@@ -53,18 +54,19 @@ def test_dropna():
     tm.assert_index_equal(idx.dropna(how="all"), expected)
 
 
-def test_nulls(idx):
+def test_nulls():
     # this is really a smoke test for the methods
     # as these are adequately tested for function elsewhere
-
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         idx.isna()
 
 
 @pytest.mark.xfail(reason="isna is not defined for MultiIndex")
-def test_hasnans_isnans(idx):
+def test_hasnans_isnans():
     # GH 11343, added tests for hasnans / isnans
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     index = idx.copy()
 
     # cases in indices doesn't include NaN
diff --git a/pandas/tests/indexes/multi/test_reindex.py b/pandas/tests/indexes/multi/test_reindex.py
index d1b4fe8b98760..007480db1de1b 100644
--- a/pandas/tests/indexes/multi/test_reindex.py
+++ b/pandas/tests/indexes/multi/test_reindex.py
@@ -9,7 +9,12 @@
 import pandas._testing as tm
 
 
-def test_reindex(idx):
+def test_reindex():
+    idx = MultiIndex(
+        levels=[list(range(5)), list(range(1, 6))],
+        codes=[list(range(5)), list(range(5))],
+        names=["first", "second"],
+    )
     result, indexer = idx.reindex(list(idx[:4]))
     assert isinstance(result, MultiIndex)
     assert result.names == ["first", "second"]
@@ -92,7 +97,8 @@ def test_reindex_lvl_preserves_type_if_target_is_empty_list_or_array(
     assert mi.reindex([], level=1)[0].levels[1].dtype == dti.dtype
 
 
-def test_reindex_base(idx):
+def test_reindex_base():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     expected = np.arange(idx.size, dtype=np.intp)
 
     actual = idx.get_indexer(idx)
diff --git a/pandas/tests/indexes/multi/test_reshape.py b/pandas/tests/indexes/multi/test_reshape.py
index 06dbb33aadf97..13d5bd1ae8d65 100644
--- a/pandas/tests/indexes/multi/test_reshape.py
+++ b/pandas/tests/indexes/multi/test_reshape.py
@@ -12,7 +12,12 @@
 import pandas._testing as tm
 
 
-def test_insert(idx):
+def test_insert():
+    idx = MultiIndex(
+        levels=[["bar", "foo"], ["two", "one"]],
+        codes=[[0, 1], [0, 1]],
+        names=["first", "second"],
+    )
     # key contained in all levels
     new_index = idx.insert(0, ("bar", "two"))
     assert new_index.equal_levels(idx)
@@ -34,6 +39,8 @@ def test_insert(idx):
     with pytest.raises(ValueError, match=msg):
         idx.insert(0, ("foo2",))
 
+
+def test_insert_reindex():
     left = pd.DataFrame([["a", "b", 0], ["b", "d", 1]], columns=["1st", "2nd", "3rd"])
     left.set_index(["1st", "2nd"], inplace=True)
     ts = left["3rd"].copy(deep=True)
@@ -90,7 +97,8 @@ def test_insert2():
     tm.assert_series_equal(left, right)
 
 
-def test_append(idx):
+def test_append():
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     result = idx[:3].append(idx[3:])
     assert result.equals(idx)
 
@@ -201,14 +209,16 @@ def test_repeat():
     tm.assert_index_equal(m.repeat(reps), expected)
 
 
-def test_insert_base(idx):
+def test_insert_base():
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     result = idx[1:4]
 
     # test 0th element
     assert idx[0:4].equals(result.insert(0, idx[0]))
 
 
-def test_delete_base(idx):
+def test_delete_base():
+    idx = MultiIndex(levels=[list(range(6))], codes=[list(range(6))])
     expected = idx[1:]
     result = idx.delete(0)
     assert result.equals(expected)
diff --git a/pandas/tests/indexes/multi/test_setops.py b/pandas/tests/indexes/multi/test_setops.py
index 0abb56ecf9de7..025381616743a 100644
--- a/pandas/tests/indexes/multi/test_setops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -21,15 +21,17 @@
 @pytest.mark.parametrize(
     "method", ["intersection", "union", "difference", "symmetric_difference"]
 )
-def test_set_ops_error_cases(idx, case, sort, method):
+def test_set_ops_error_cases(case, sort, method):
     # non-iterable input
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "Input must be Index or array-like"
     with pytest.raises(TypeError, match=msg):
         getattr(idx, method)(case, sort=sort)
 
 
 @pytest.mark.parametrize("klass", [MultiIndex, np.array, Series, list])
-def test_intersection_base(idx, sort, klass):
+def test_intersection_base(sort, klass):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     first = idx[2::-1]  # first 3 elements reversed
     second = idx[:5]
 
@@ -50,7 +52,8 @@ def test_intersection_base(idx, sort, klass):
 
 @pytest.mark.arm_slow
 @pytest.mark.parametrize("klass", [MultiIndex, np.array, Series, list])
-def test_union_base(idx, sort, klass):
+def test_union_base(sort, klass):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     first = idx[::-1]
     second = idx[:5]
 
@@ -69,7 +72,8 @@ def test_union_base(idx, sort, klass):
         first.union([1, 2, 3], sort=sort)
 
 
-def test_difference_base(idx, sort):
+def test_difference_base(sort):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     second = idx[4:]
     answer = idx[:4]
     result = idx.difference(second, sort=sort)
@@ -91,7 +95,8 @@ def test_difference_base(idx, sort):
         idx.difference([1, 2, 3], sort=sort)
 
 
-def test_symmetric_difference(idx, sort):
+def test_symmetric_difference(sort):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     first = idx[1:]
     second = idx[:-1]
     answer = idx[[-1, 0]]
@@ -124,13 +129,18 @@ def test_multiindex_symmetric_difference():
     assert result.names == [None, None]
 
 
-def test_empty(idx):
+def test_empty():
     # GH 15270
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert not idx.empty
     assert idx[:0].empty
 
 
-def test_difference(idx, sort):
+def test_difference(sort):
+    idx = MultiIndex(
+        levels=[list(range(5)), list(range(1, 6))],
+        codes=[list(range(5)), list(range(5))],
+    )
     first = idx
     result = first.difference(idx[-3:], sort=sort)
     vals = idx[:-3].values
@@ -237,7 +247,8 @@ def test_difference_sort_incomparable_true():
         idx.difference(other, sort=True)
 
 
-def test_union(idx, sort):
+def test_union(sort):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     piece1 = idx[:5][::-1]
     piece2 = idx[3:]
 
@@ -282,7 +293,8 @@ def test_union_with_regular_index(idx, using_infer_string):
         assert not result.equals(result2)
 
 
-def test_intersection(idx, sort):
+def test_intersection(sort):
+    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
     piece1 = idx[:5][::-1]
     piece2 = idx[3:]
 
@@ -310,7 +322,8 @@ def test_intersection(idx, sort):
 @pytest.mark.parametrize(
     "method", ["intersection", "union", "difference", "symmetric_difference"]
 )
-def test_setop_with_categorical(idx, sort, method):
+def test_setop_with_categorical(sort, method):
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     other = idx.to_flat_index().astype("category")
     res_names = [None] * idx.nlevels
 
@@ -323,7 +336,8 @@ def test_setop_with_categorical(idx, sort, method):
     tm.assert_index_equal(result, expected)
 
 
-def test_intersection_non_object(idx, sort):
+def test_intersection_non_object(sort):
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     other = Index(range(3), name="foo")
 
     result = idx.intersection(other, sort=sort)
diff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py
index b4dcef71dcf50..4748016d2943e 100644
--- a/pandas/tests/indexes/multi/test_sorting.py
+++ b/pandas/tests/indexes/multi/test_sorting.py
@@ -7,11 +7,9 @@
 )
 
 from pandas import (
-    CategoricalIndex,
     DataFrame,
     Index,
     MultiIndex,
-    RangeIndex,
     Series,
     Timestamp,
 )
@@ -19,7 +17,8 @@
 from pandas.core.indexes.frozen import FrozenList
 
 
-def test_sortlevel(idx):
+def test_sortlevel():
+    idx = MultiIndex(levels=[[0, 1], [1, 2]], codes=[[0, 1], [0, 1]])
     tuples = list(idx)
     np.random.default_rng(2).shuffle(tuples)
 
@@ -83,31 +82,12 @@ def test_sortlevel_na_position():
     tm.assert_index_equal(result, expected)
 
 
-def test_numpy_argsort(idx):
+def test_numpy_argsort():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = np.argsort(idx)
     expected = idx.argsort()
     tm.assert_numpy_array_equal(result, expected)
 
-    # these are the only two types that perform
-    # pandas compatibility input validation - the
-    # rest already perform separate (or no) such
-    # validation via their 'values' attribute as
-    # defined in pandas.core.indexes/base.py - they
-    # cannot be changed at the moment due to
-    # backwards compatibility concerns
-    if isinstance(type(idx), (CategoricalIndex, RangeIndex)):
-        msg = "the 'axis' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.argsort(idx, axis=1)
-
-        msg = "the 'kind' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.argsort(idx, kind="mergesort")
-
-        msg = "the 'order' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            np.argsort(idx, order=("a", "b"))
-
 
 def test_unsortedindex():
     # GH 11897
@@ -277,7 +257,8 @@ def test_remove_unused_nan(level0, level1):
         assert "unused" not in result.levels[level]
 
 
-def test_argsort(idx):
+def test_argsort():
+    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     result = idx.argsort()
     expected = idx.values.argsort()
     tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_take.py b/pandas/tests/indexes/multi/test_take.py
index 543cba25c373b..6ae927137a304 100644
--- a/pandas/tests/indexes/multi/test_take.py
+++ b/pandas/tests/indexes/multi/test_take.py
@@ -11,13 +11,17 @@ def test_take(idx):
     expected = idx[indexer]
     assert result.equals(expected)
 
+
+def test_freq():
     # GH 10791
+    idx = pd.MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "'MultiIndex' object has no attribute 'freq'"
     with pytest.raises(AttributeError, match=msg):
         idx.freq
 
 
-def test_take_invalid_kwargs(idx):
+def test_take_invalid_kwargs():
+    idx = pd.MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     indices = [1, 2]
 
     msg = r"take\(\) got an unexpected keyword argument 'foo'"

From 29e7cd570ca46d4618492bec4937153afed4fba4 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Sat, 23 Dec 2023 21:27:48 -0800
Subject: [PATCH 03/12] Remove other seldom used fixtures

---
 pandas/tests/arithmetic/test_numeric.py       | 21 +-----
 pandas/tests/dtypes/test_inference.py         |  7 +-
 pandas/tests/frame/indexing/test_indexing.py  | 34 +++------
 pandas/tests/frame/methods/test_join.py       | 26 ++-----
 pandas/tests/frame/methods/test_nlargest.py   | 34 ++++-----
 pandas/tests/frame/test_subclass.py           | 21 +++---
 pandas/tests/frame/test_validate.py           |  8 +--
 pandas/tests/generic/test_finalize.py         |  9 +--
 .../generic/test_label_or_level_utils.py      | 13 +---
 pandas/tests/groupby/methods/test_describe.py | 65 +++++++----------
 .../groupby/methods/test_value_counts.py      | 57 ++++++---------
 pandas/tests/groupby/test_all_methods.py      | 69 +++++++++----------
 pandas/tests/groupby/test_index_as_string.py  | 53 ++++++--------
 pandas/tests/groupby/test_indexing.py         | 43 +++++-------
 pandas/tests/groupby/test_raises.py           | 24 +++----
 .../tests/indexes/datetimelike_/test_nat.py   | 59 +++++++---------
 .../indexes/interval/test_constructors.py     | 29 +++-----
 .../indexes/interval/test_interval_tree.py    |  6 +-
 pandas/tests/indexes/numeric/test_indexing.py | 11 ++-
 pandas/tests/indexes/numeric/test_numeric.py  | 29 +++-----
 pandas/tests/indexes/numeric/test_setops.py   |  6 +-
 pandas/tests/indexing/multiindex/test_loc.py  | 14 ++--
 pandas/tests/interchange/test_impl.py         | 34 ++++-----
 pandas/tests/io/test_orc.py                   | 27 +++-----
 pandas/tests/test_downstream.py               | 48 ++++---------
 25 files changed, 274 insertions(+), 473 deletions(-)

diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index d8c1786b6b422..4e978a874b15d 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -37,14 +37,6 @@ def switch_numexpr_min_elements(request, monkeypatch):
         yield request.param
 
 
-@pytest.fixture(params=[Index, Series, tm.to_array])
-def box_pandas_1d_array(request):
-    """
-    Fixture to test behavior for Index, Series and tm.to_array classes
-    """
-    return request.param
-
-
 @pytest.fixture(
     params=[
         # TODO: add more  dtypes here
@@ -62,17 +54,6 @@ def numeric_idx(request):
     return request.param
 
 
-@pytest.fixture(
-    params=[Index, Series, tm.to_array, np.array, list], ids=lambda x: x.__name__
-)
-def box_1d_array(request):
-    """
-    Fixture to test behavior for Index, Series, tm.to_array, numpy Array and list
-    classes
-    """
-    return request.param
-
-
 def adjust_negative_zero(zero, expected):
     """
     Helper to adjust the expected result if we are dividing by -0.0
@@ -1503,6 +1484,8 @@ def test_dataframe_div_silenced():
     "data, expected_data",
     [([0, 1, 2], [0, 2, 4])],
 )
+@pytest.mark.parametrize("box_pandas_1d_array", [Index, Series, tm.to_array])
+@pytest.mark.parametrize("box_1d_array", [Index, Series, tm.to_array, np.array, list])
 def test_integer_array_add_list_like(
     box_pandas_1d_array, box_1d_array, data, expected_data
 ):
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 49eb06c299886..e58fd03b8e306 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -1983,9 +1983,12 @@ def test_nan_to_nat_conversions():
 
 
 @pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")
+@pytest.mark.parametrize("spmatrix", ["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
 def test_is_scipy_sparse(spmatrix):
-    pytest.importorskip("scipy")
-    assert is_scipy_sparse(spmatrix([[0, 1]]))
+    sparse = pytest.importorskip("scipy.sparse")
+
+    klass = getattr(sparse, spmatrix + "_matrix")
+    assert is_scipy_sparse(klass([[0, 1]]))
     assert not is_scipy_sparse(np.array([1]))
 
 
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 97e7ae15c6c63..a43f32778a048 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1673,25 +1673,6 @@ def orig(self):
         orig = DataFrame({"cats": cats, "values": values}, index=idx)
         return orig
 
-    @pytest.fixture
-    def exp_single_row(self):
-        # The expected values if we change a single row
-        cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
-        idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values1 = [1, 1, 2, 1, 1, 1, 1]
-        exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
-        return exp_single_row
-
-    @pytest.fixture
-    def exp_multi_row(self):
-        # assign multiple rows (mixed values) (-> array) -> exp_multi_row
-        # changed multiple rows
-        cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
-        idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
-        values2 = [1, 1, 2, 2, 1, 1, 1]
-        exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
-        return exp_multi_row
-
     @pytest.fixture
     def exp_parts_cats_col(self):
         # changed part of the cats column
@@ -1713,7 +1694,7 @@ def exp_single_cats_value(self):
         return exp_single_cats_value
 
     @pytest.mark.parametrize("indexer", [tm.loc, tm.iloc])
-    def test_loc_iloc_setitem_list_of_lists(self, orig, exp_multi_row, indexer):
+    def test_loc_iloc_setitem_list_of_lists(self, orig, indexer):
         #   - assign multiple rows (mixed values) -> exp_multi_row
         df = orig.copy()
 
@@ -1722,6 +1703,11 @@ def test_loc_iloc_setitem_list_of_lists(self, orig, exp_multi_row, indexer):
             key = slice("j", "k")
 
         indexer(df)[key, :] = [["b", 2], ["b", 2]]
+
+        cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
+        idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values2 = [1, 1, 2, 2, 1, 1, 1]
+        exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
         tm.assert_frame_equal(df, exp_multi_row)
 
         df = orig.copy()
@@ -1763,9 +1749,7 @@ def test_loc_iloc_setitem_mask_single_value_in_categories(
         tm.assert_frame_equal(df, exp_single_cats_value)
 
     @pytest.mark.parametrize("indexer", [tm.loc, tm.iloc])
-    def test_loc_iloc_setitem_full_row_non_categorical_rhs(
-        self, orig, exp_single_row, indexer
-    ):
+    def test_loc_iloc_setitem_full_row_non_categorical_rhs(self, orig, indexer):
         #   - assign a complete row (mixed values) -> exp_single_row
         df = orig.copy()
 
@@ -1775,6 +1759,10 @@ def test_loc_iloc_setitem_full_row_non_categorical_rhs(
 
         # not categorical dtype, but "b" _is_ among the categories for df["cat"]
         indexer(df)[key, :] = ["b", 2]
+        cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
+        idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
+        values1 = [1, 1, 2, 1, 1, 1, 1]
+        exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
         tm.assert_frame_equal(df, exp_single_row)
 
         # "c" is not among the categories for df["cat"]
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 735f6c50ab739..06c0f6ea3c5c0 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -17,25 +17,6 @@
 from pandas.core.reshape.concat import concat
 
 
-@pytest.fixture
-def frame_with_period_index():
-    return DataFrame(
-        data=np.arange(20).reshape(4, 5),
-        columns=list("abcde"),
-        index=period_range(start="2000", freq="Y", periods=4),
-    )
-
-
-@pytest.fixture
-def left():
-    return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
-
-
-@pytest.fixture
-def right():
-    return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
-
-
 @pytest.fixture
 def left_no_dup():
     return DataFrame(
@@ -113,6 +94,8 @@ def right_w_dups(right_no_dup):
     ],
 )
 def test_join(left, right, how, sort, expected):
+    left = DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+    right = DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
     result = left.join(right, how=how, sort=sort, validate="1:1")
     tm.assert_frame_equal(result, expected)
 
@@ -348,6 +331,11 @@ def test_join_overlap(float_frame):
 
 
 def test_join_period_index(frame_with_period_index):
+    frame_with_period_index = DataFrame(
+        data=np.arange(20).reshape(4, 5),
+        columns=list("abcde"),
+        index=period_range(start="2000", freq="Y", periods=4),
+    )
     other = frame_with_period_index.rename(columns=lambda key: f"{key}{key}")
 
     joined_values = np.concatenate([frame_with_period_index.values] * 2, axis=1)
diff --git a/pandas/tests/frame/methods/test_nlargest.py b/pandas/tests/frame/methods/test_nlargest.py
index 3ba893501914a..22227bbb62d39 100644
--- a/pandas/tests/frame/methods/test_nlargest.py
+++ b/pandas/tests/frame/methods/test_nlargest.py
@@ -12,25 +12,6 @@
 from pandas.util.version import Version
 
 
-@pytest.fixture
-def df_duplicates():
-    return pd.DataFrame(
-        {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
-        index=[0, 0, 1, 1, 1],
-    )
-
-
-@pytest.fixture
-def df_strings():
-    return pd.DataFrame(
-        {
-            "a": np.random.default_rng(2).permutation(10),
-            "b": list(ascii_lowercase[:10]),
-            "c": np.random.default_rng(2).permutation(10).astype("float64"),
-        }
-    )
-
-
 @pytest.fixture
 def df_main_dtypes():
     return pd.DataFrame(
@@ -83,7 +64,13 @@ class TestNLargestNSmallest:
     @pytest.mark.parametrize("n", range(1, 11))
     def test_nlargest_n(self, df_strings, nselect_method, n, order):
         # GH#10393
-        df = df_strings
+        df = pd.DataFrame(
+            {
+                "a": np.random.default_rng(2).permutation(10),
+                "b": list(ascii_lowercase[:10]),
+                "c": np.random.default_rng(2).permutation(10).astype("float64"),
+            }
+        )
         if "b" in order:
             error_msg = (
                 f"Column 'b' has dtype (object|string), "
@@ -156,10 +143,13 @@ def test_nlargest_n_identical_values(self):
         [["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
     )
     @pytest.mark.parametrize("n", range(1, 6))
-    def test_nlargest_n_duplicate_index(self, df_duplicates, n, order, request):
+    def test_nlargest_n_duplicate_index(self, n, order, request):
         # GH#13412
 
-        df = df_duplicates
+        df = pd.DataFrame(
+            {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
+            index=[0, 0, 1, 1, 1],
+        )
         result = df.nsmallest(n, order)
         expected = df.sort_values(order).head(n)
         tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index ef78ae62cb4d6..cf4f2071a8aae 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -15,16 +15,6 @@
 )
 
 
-@pytest.fixture()
-def gpd_style_subclass_df():
-    class SubclassedDataFrame(DataFrame):
-        @property
-        def _constructor(self):
-            return SubclassedDataFrame
-
-    return SubclassedDataFrame({"a": [1, 2, 3]})
-
-
 class TestDataFrameSubclassing:
     def test_frame_subclassing_and_slicing(self):
         # Subclass frame and ensure it returns the right class on slicing it
@@ -716,8 +706,15 @@ def test_convert_dtypes_preserves_subclass(self, gpd_style_subclass_df):
         result = df.convert_dtypes()
         assert isinstance(result, tm.SubclassedDataFrame)
 
-        result = gpd_style_subclass_df.convert_dtypes()
-        assert isinstance(result, type(gpd_style_subclass_df))
+    def test_convert_dtypes_preserves_subclass_with_constructor(self):
+        class SubclassedDataFrame(DataFrame):
+            @property
+            def _constructor(self):
+                return SubclassedDataFrame
+
+        df = SubclassedDataFrame({"a": [1, 2, 3]})
+        result = df.convert_dtypes()
+        assert isinstance(result, SubclassedDataFrame)
 
     def test_astype_preserves_subclass(self):
         # GH#40810
diff --git a/pandas/tests/frame/test_validate.py b/pandas/tests/frame/test_validate.py
index e99e0a6863848..fdeecba29a617 100644
--- a/pandas/tests/frame/test_validate.py
+++ b/pandas/tests/frame/test_validate.py
@@ -3,11 +3,6 @@
 from pandas.core.frame import DataFrame
 
 
-@pytest.fixture
-def dataframe():
-    return DataFrame({"a": [1, 2], "b": [3, 4]})
-
-
 class TestDataFrameValidate:
     """Tests for error handling related to data types of method arguments."""
 
@@ -24,7 +19,8 @@ class TestDataFrameValidate:
         ],
     )
     @pytest.mark.parametrize("inplace", [1, "True", [1, 2, 3], 5.0])
-    def test_validate_bool_args(self, dataframe, func, inplace):
+    def test_validate_bool_args(self, func, inplace):
+        dataframe = DataFrame({"a": [1, 2], "b": [3, 4]})
         msg = 'For argument "inplace" expected type bool'
         kwargs = {"inplace": inplace}
 
diff --git a/pandas/tests/generic/test_finalize.py b/pandas/tests/generic/test_finalize.py
index 866e9e203ffe3..f25e7d4ab8c79 100644
--- a/pandas/tests/generic/test_finalize.py
+++ b/pandas/tests/generic/test_finalize.py
@@ -386,18 +386,11 @@ def idfn(x):
         return str(x)
 
 
-@pytest.fixture(params=_all_methods, ids=lambda x: idfn(x[-1]))
-def ndframe_method(request):
-    """
-    An NDFrame method returning an NDFrame.
-    """
-    return request.param
-
-
 @pytest.mark.filterwarnings(
     "ignore:DataFrame.fillna with 'method' is deprecated:FutureWarning",
     "ignore:last is deprecated:FutureWarning",
 )
+@pytest.mark.parametrize("ndframe_method", _all_methods, ids=lambda x: idfn(x[-1]))
 def test_finalize_called(ndframe_method):
     cls, init_args, method = ndframe_method
     ndframe = cls(*init_args)
diff --git a/pandas/tests/generic/test_label_or_level_utils.py b/pandas/tests/generic/test_label_or_level_utils.py
index 97be46f716d7d..80c24c647bc11 100644
--- a/pandas/tests/generic/test_label_or_level_utils.py
+++ b/pandas/tests/generic/test_label_or_level_utils.py
@@ -34,15 +34,6 @@ def df_ambig(df):
     return df
 
 
-@pytest.fixture
-def df_duplabels(df):
-    """DataFrame with level 'L1' and labels 'L2', 'L3', and 'L2'"""
-    df = df.set_index(["L1"])
-    df = pd.concat([df, df["L2"]], axis=1)
-
-    return df
-
-
 # Test is label/level reference
 # =============================
 def get_labels_levels(df_levels):
@@ -229,7 +220,9 @@ def test_get_label_or_level_values_df_ambig(df_ambig, axis):
     assert_label_values(df_ambig, ["L3"], axis=axis)
 
 
-def test_get_label_or_level_values_df_duplabels(df_duplabels, axis):
+def test_get_label_or_level_values_df_duplabels(df, axis):
+    df = df.set_index(["L1"])
+    df_duplabels = pd.concat([df, df["L2"]], axis=1)
     axis = df_duplabels._get_axis_number(axis)
     # Transpose frame if axis == 1
     if axis == 1:
diff --git a/pandas/tests/groupby/methods/test_describe.py b/pandas/tests/groupby/methods/test_describe.py
index a2440e09dfc02..2e75694f7acc7 100644
--- a/pandas/tests/groupby/methods/test_describe.py
+++ b/pandas/tests/groupby/methods/test_describe.py
@@ -227,49 +227,34 @@ def test_describe_duplicate_columns():
     tm.assert_frame_equal(result, expected)
 
 
-class TestGroupByNonCythonPaths:
+def test_describe_non_cython_paths():
     # GH#5610 non-cython calls should not include the grouper
     # Tests for code not expected to go through cython paths.
+    df = DataFrame(
+        [[1, 2, "foo"], [1, np.nan, "bar"], [3, np.nan, "baz"]],
+        columns=["A", "B", "C"],
+    )
+    gb = df.groupby("A")
+    expected_index = Index([1, 3], name="A")
+    expected_col = MultiIndex(
+        levels=[["B"], ["count", "mean", "std", "min", "25%", "50%", "75%", "max"]],
+        codes=[[0] * 8, list(range(8))],
+    )
+    expected = DataFrame(
+        [
+            [1.0, 2.0, np.nan, 2.0, 2.0, 2.0, 2.0, 2.0],
+            [0.0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+        ],
+        index=expected_index,
+        columns=expected_col,
+    )
+    result = gb.describe()
+    tm.assert_frame_equal(result, expected)
 
-    @pytest.fixture
-    def df(self):
-        df = DataFrame(
-            [[1, 2, "foo"], [1, np.nan, "bar"], [3, np.nan, "baz"]],
-            columns=["A", "B", "C"],
-        )
-        return df
-
-    @pytest.fixture
-    def gb(self, df):
-        gb = df.groupby("A")
-        return gb
-
-    @pytest.fixture
-    def gni(self, df):
-        gni = df.groupby("A", as_index=False)
-        return gni
-
-    def test_describe(self, df, gb, gni):
-        # describe
-        expected_index = Index([1, 3], name="A")
-        expected_col = MultiIndex(
-            levels=[["B"], ["count", "mean", "std", "min", "25%", "50%", "75%", "max"]],
-            codes=[[0] * 8, list(range(8))],
-        )
-        expected = DataFrame(
-            [
-                [1.0, 2.0, np.nan, 2.0, 2.0, 2.0, 2.0, 2.0],
-                [0.0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
-            ],
-            index=expected_index,
-            columns=expected_col,
-        )
-        result = gb.describe()
-        tm.assert_frame_equal(result, expected)
-
-        expected = expected.reset_index()
-        result = gni.describe()
-        tm.assert_frame_equal(result, expected)
+    gni = df.groupby("A", as_index=False)
+    expected = expected.reset_index()
+    result = gni.describe()
+    tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("dtype", [int, float, object])
diff --git a/pandas/tests/groupby/methods/test_value_counts.py b/pandas/tests/groupby/methods/test_value_counts.py
index 2fa79c815d282..0301c51b7f538 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -423,14 +423,6 @@ def test_compound(
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.fixture
-def animals_df():
-    return DataFrame(
-        {"key": [1, 1, 1, 1], "num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
-        index=["falcon", "dog", "cat", "ant"],
-    )
-
-
 @pytest.mark.parametrize(
     "sort, ascending, normalize, name, expected_data, expected_index",
     [
@@ -448,10 +440,14 @@ def animals_df():
     ],
 )
 def test_data_frame_value_counts(
-    animals_df, sort, ascending, normalize, name, expected_data, expected_index
+    sort, ascending, normalize, name, expected_data, expected_index
 ):
     # 3-way compare with :meth:`~DataFrame.value_counts`
     # Tests from frame/methods/test_value_counts.py
+    animals_df = DataFrame(
+        {"key": [1, 1, 1, 1], "num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+        index=["falcon", "dog", "cat", "ant"],
+    )
     result_frame = animals_df.value_counts(
         sort=sort, ascending=ascending, normalize=normalize
     )
@@ -471,19 +467,6 @@ def test_data_frame_value_counts(
     tm.assert_series_equal(result_frame_groupby, expected)
 
 
-@pytest.fixture
-def nulls_df():
-    n = np.nan
-    return DataFrame(
-        {
-            "A": [1, 1, n, 4, n, 6, 6, 6, 6],
-            "B": [1, 1, 3, n, n, 6, 6, 6, 6],
-            "C": [1, 2, 3, 4, 5, 6, n, 8, n],
-            "D": [1, 2, 3, 4, 5, 6, 7, n, n],
-        }
-    )
-
-
 @pytest.mark.parametrize(
     "group_dropna, count_dropna, expected_rows, expected_values",
     [
@@ -499,7 +482,7 @@ def nulls_df():
     ],
 )
 def test_dropna_combinations(
-    nulls_df, group_dropna, count_dropna, expected_rows, expected_values, request
+    group_dropna, count_dropna, expected_rows, expected_values, request
 ):
     if Version(np.__version__) >= Version("1.25") and not group_dropna:
         request.applymarker(
@@ -511,6 +494,14 @@ def test_dropna_combinations(
                 strict=False,
             )
         )
+    nulls_df = DataFrame(
+        {
+            "A": [1, 1, np.nan, 4, np.nan, 6, 6, 6, 6],
+            "B": [1, 1, 3, np.nan, np.nan, 6, 6, 6, 6],
+            "C": [1, 2, 3, 4, 5, 6, np.nan, 8, np.nan],
+            "D": [1, 2, 3, 4, 5, 6, 7, np.nan, np.nan],
+        }
+    )
     gp = nulls_df.groupby(["A", "B"], dropna=group_dropna)
     result = gp.value_counts(normalize=True, sort=True, dropna=count_dropna)
     columns = DataFrame()
@@ -521,17 +512,6 @@ def test_dropna_combinations(
     tm.assert_series_equal(result, expected)
 
 
-@pytest.fixture
-def names_with_nulls_df(nulls_fixture):
-    return DataFrame(
-        {
-            "key": [1, 1, 1, 1],
-            "first_name": ["John", "Anne", "John", "Beth"],
-            "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
-        },
-    )
-
-
 @pytest.mark.parametrize(
     "dropna, expected_data, expected_index",
     [
@@ -560,11 +540,18 @@ def names_with_nulls_df(nulls_fixture):
 )
 @pytest.mark.parametrize("normalize, name", [(False, "count"), (True, "proportion")])
 def test_data_frame_value_counts_dropna(
-    names_with_nulls_df, dropna, normalize, name, expected_data, expected_index
+    nulls_fixture, dropna, normalize, name, expected_data, expected_index
 ):
     # GH 41334
     # 3-way compare with :meth:`~DataFrame.value_counts`
     # Tests with nulls from frame/methods/test_value_counts.py
+    names_with_nulls_df = DataFrame(
+        {
+            "key": [1, 1, 1, 1],
+            "first_name": ["John", "Anne", "John", "Beth"],
+            "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
+        },
+    )
     result_frame = names_with_nulls_df.value_counts(dropna=dropna, normalize=normalize)
     expected = Series(
         data=expected_data,
diff --git a/pandas/tests/groupby/test_all_methods.py b/pandas/tests/groupby/test_all_methods.py
index ad35bec70f668..9560310489a54 100644
--- a/pandas/tests/groupby/test_all_methods.py
+++ b/pandas/tests/groupby/test_all_methods.py
@@ -18,45 +18,44 @@
 import pandas._testing as tm
 from pandas.tests.groupby import get_groupby_method_args
 
+# def test_multiindex_group_all_columns_when_empty(groupby_func):
+#     # GH 32464
+#     df = DataFrame({"a": [], "b": [], "c": []}).set_index(["a", "b", "c"])
+#     gb = df.groupby(["a", "b", "c"], group_keys=False)
+#     method = getattr(gb, groupby_func)
+#     args = get_groupby_method_args(groupby_func, df)
 
-def test_multiindex_group_all_columns_when_empty(groupby_func):
-    # GH 32464
-    df = DataFrame({"a": [], "b": [], "c": []}).set_index(["a", "b", "c"])
-    gb = df.groupby(["a", "b", "c"], group_keys=False)
-    method = getattr(gb, groupby_func)
-    args = get_groupby_method_args(groupby_func, df)
-
-    warn = FutureWarning if groupby_func == "fillna" else None
-    warn_msg = "DataFrameGroupBy.fillna is deprecated"
-    with tm.assert_produces_warning(warn, match=warn_msg):
-        result = method(*args).index
-    expected = df.index
-    tm.assert_index_equal(result, expected)
+#     warn = FutureWarning if groupby_func == "fillna" else None
+#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
+#     with tm.assert_produces_warning(warn, match=warn_msg):
+#         result = method(*args).index
+#     expected = df.index
+#     tm.assert_index_equal(result, expected)
 
 
-def test_duplicate_columns(request, groupby_func, as_index):
-    # GH#50806
-    if groupby_func == "corrwith":
-        msg = "GH#50845 - corrwith fails when there are duplicate columns"
-        request.applymarker(pytest.mark.xfail(reason=msg))
-    df = DataFrame([[1, 3, 6], [1, 4, 7], [2, 5, 8]], columns=list("abb"))
-    args = get_groupby_method_args(groupby_func, df)
-    gb = df.groupby("a", as_index=as_index)
-    warn = FutureWarning if groupby_func == "fillna" else None
-    warn_msg = "DataFrameGroupBy.fillna is deprecated"
-    with tm.assert_produces_warning(warn, match=warn_msg):
-        result = getattr(gb, groupby_func)(*args)
+# def test_duplicate_columns(request, groupby_func, as_index):
+#     # GH#50806
+#     if groupby_func == "corrwith":
+#         msg = "GH#50845 - corrwith fails when there are duplicate columns"
+#         request.applymarker(pytest.mark.xfail(reason=msg))
+#     df = DataFrame([[1, 3, 6], [1, 4, 7], [2, 5, 8]], columns=list("abb"))
+#     args = get_groupby_method_args(groupby_func, df)
+#     gb = df.groupby("a", as_index=as_index)
+#     warn = FutureWarning if groupby_func == "fillna" else None
+#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
+#     with tm.assert_produces_warning(warn, match=warn_msg):
+#         result = getattr(gb, groupby_func)(*args)
 
-    expected_df = df.set_axis(["a", "b", "c"], axis=1)
-    expected_args = get_groupby_method_args(groupby_func, expected_df)
-    expected_gb = expected_df.groupby("a", as_index=as_index)
-    warn = FutureWarning if groupby_func == "fillna" else None
-    warn_msg = "DataFrameGroupBy.fillna is deprecated"
-    with tm.assert_produces_warning(warn, match=warn_msg):
-        expected = getattr(expected_gb, groupby_func)(*expected_args)
-    if groupby_func not in ("size", "ngroup", "cumcount"):
-        expected = expected.rename(columns={"c": "b"})
-    tm.assert_equal(result, expected)
+#     expected_df = df.set_axis(["a", "b", "c"], axis=1)
+#     expected_args = get_groupby_method_args(groupby_func, expected_df)
+#     expected_gb = expected_df.groupby("a", as_index=as_index)
+#     warn = FutureWarning if groupby_func == "fillna" else None
+#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
+#     with tm.assert_produces_warning(warn, match=warn_msg):
+#         expected = getattr(expected_gb, groupby_func)(*expected_args)
+#     if groupby_func not in ("size", "ngroup", "cumcount"):
+#         expected = expected.rename(columns={"c": "b"})
+#     tm.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 4aaf3de9a23b2..6d0e07b19b665 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -5,38 +5,6 @@
 import pandas._testing as tm
 
 
-@pytest.fixture(params=[["inner"], ["inner", "outer"]])
-def frame(request):
-    levels = request.param
-    df = pd.DataFrame(
-        {
-            "outer": ["a", "a", "a", "b", "b", "b"],
-            "inner": [1, 2, 3, 1, 2, 3],
-            "A": np.arange(6),
-            "B": ["one", "one", "two", "two", "one", "one"],
-        }
-    )
-    if levels:
-        df = df.set_index(levels)
-
-    return df
-
-
-@pytest.fixture()
-def series():
-    df = pd.DataFrame(
-        {
-            "outer": ["a", "a", "a", "b", "b", "b"],
-            "inner": [1, 2, 3, 1, 2, 3],
-            "A": np.arange(6),
-            "B": ["one", "one", "two", "two", "one", "one"],
-        }
-    )
-    s = df.set_index(["outer", "inner", "B"])["A"]
-
-    return s
-
-
 @pytest.mark.parametrize(
     "key_strs,groupers",
     [
@@ -46,7 +14,17 @@ def series():
         (["inner", "B"], [pd.Grouper(level="inner"), "B"]),  # Index and column
     ],
 )
-def test_grouper_index_level_as_string(frame, key_strs, groupers):
+@pytest.mark.parametrize("levels", [["inner"], ["inner", "outer"]])
+def test_grouper_index_level_as_string(levels, key_strs, groupers):
+    frame = pd.DataFrame(
+        {
+            "outer": ["a", "a", "a", "b", "b", "b"],
+            "inner": [1, 2, 3, 1, 2, 3],
+            "A": np.arange(6),
+            "B": ["one", "one", "two", "two", "one", "one"],
+        }
+    )
+    frame = frame.set_index(levels)
     if "B" not in key_strs or "outer" in frame.columns:
         result = frame.groupby(key_strs).mean(numeric_only=True)
         expected = frame.groupby(groupers).mean(numeric_only=True)
@@ -73,6 +51,15 @@ def test_grouper_index_level_as_string(frame, key_strs, groupers):
 )
 def test_grouper_index_level_as_string_series(series, levels):
     # Compute expected result
+    df = pd.DataFrame(
+        {
+            "outer": ["a", "a", "a", "b", "b", "b"],
+            "inner": [1, 2, 3, 1, 2, 3],
+            "A": np.arange(6),
+            "B": ["one", "one", "two", "two", "one", "one"],
+        }
+    )
+    series = df.set_index(["outer", "inner", "B"])["A"]
     if isinstance(levels, list):
         groupers = [pd.Grouper(level=lv) for lv in levels]
     else:
diff --git a/pandas/tests/groupby/test_indexing.py b/pandas/tests/groupby/test_indexing.py
index 664c52babac13..4974e13a1b6ea 100644
--- a/pandas/tests/groupby/test_indexing.py
+++ b/pandas/tests/groupby/test_indexing.py
@@ -118,15 +118,26 @@ def test_doc_examples():
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.fixture()
-def multiindex_data():
+def test_multiindex():
+    # Test the multiindex mentioned as the use-case in the documentation
+
+    def _make_df_from_data(data):
+        rows = {}
+        for date in data:
+            for level in data[date]:
+                rows[(date, level[0])] = {"A": level[1], "B": level[2]}
+
+        df = pd.DataFrame.from_dict(rows, orient="index")
+        df.index.names = ("Date", "Item")
+        return df
+
     rng = np.random.default_rng(2)
     ndates = 100
     nitems = 20
     dates = pd.date_range("20130101", periods=ndates, freq="D")
     items = [f"item {i}" for i in range(nitems)]
 
-    data = {}
+    multiindex_data = {}
     for date in dates:
         nitems_for_date = nitems - rng.integers(0, 12)
         levels = [
@@ -134,24 +145,8 @@ def multiindex_data():
             for item in items[:nitems_for_date]
         ]
         levels.sort(key=lambda x: x[1])
-        data[date] = levels
-
-    return data
-
+        multiindex_data[date] = levels
 
-def _make_df_from_data(data):
-    rows = {}
-    for date in data:
-        for level in data[date]:
-            rows[(date, level[0])] = {"A": level[1], "B": level[2]}
-
-    df = pd.DataFrame.from_dict(rows, orient="index")
-    df.index.names = ("Date", "Item")
-    return df
-
-
-def test_multiindex(multiindex_data):
-    # Test the multiindex mentioned as the use-case in the documentation
     df = _make_df_from_data(multiindex_data)
     result = df.groupby("Date", as_index=False).nth(slice(3, -3))
 
@@ -271,15 +266,11 @@ def test_step(step):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.fixture()
-def column_group_df():
-    return pd.DataFrame(
+def test_column_axis():
+    column_group_df = pd.DataFrame(
         [[0, 1, 2, 3, 4, 5, 6], [0, 0, 1, 0, 1, 0, 2]],
         columns=["A", "B", "C", "D", "E", "F", "G"],
     )
-
-
-def test_column_axis(column_group_df):
     msg = "DataFrame.groupby with axis=1"
     with tm.assert_produces_warning(FutureWarning, match=msg):
         g = column_group_df.groupby(column_group_df.iloc[1], axis=1)
diff --git a/pandas/tests/groupby/test_raises.py b/pandas/tests/groupby/test_raises.py
index 0b451ce73db89..738711019b5fd 100644
--- a/pandas/tests/groupby/test_raises.py
+++ b/pandas/tests/groupby/test_raises.py
@@ -67,19 +67,6 @@ def df_with_datetime_col():
     return df
 
 
-@pytest.fixture
-def df_with_timedelta_col():
-    df = DataFrame(
-        {
-            "a": [1, 1, 1, 1, 1, 2, 2, 2, 2],
-            "b": [3, 3, 4, 4, 4, 4, 4, 3, 3],
-            "c": range(9),
-            "d": datetime.timedelta(days=1),
-        }
-    )
-    return df
-
-
 @pytest.fixture
 def df_with_cat_col():
     df = DataFrame(
@@ -353,8 +340,15 @@ def test_groupby_raises_datetime_np(
 
 
 @pytest.mark.parametrize("func", ["prod", "cumprod", "skew", "var"])
-def test_groupby_raises_timedelta(func, df_with_timedelta_col):
-    df = df_with_timedelta_col
+def test_groupby_raises_timedelta(func):
+    df = DataFrame(
+        {
+            "a": [1, 1, 1, 1, 1, 2, 2, 2, 2],
+            "b": [3, 3, 4, 4, 4, 4, 4, 3, 3],
+            "c": range(9),
+            "d": datetime.timedelta(days=1),
+        }
+    )
     gb = df.groupby(by="a")
 
     _call_and_check(
diff --git a/pandas/tests/indexes/datetimelike_/test_nat.py b/pandas/tests/indexes/datetimelike_/test_nat.py
index 50cf29d016355..47a5e4638e69d 100644
--- a/pandas/tests/indexes/datetimelike_/test_nat.py
+++ b/pandas/tests/indexes/datetimelike_/test_nat.py
@@ -10,44 +10,33 @@
 import pandas._testing as tm
 
 
-class NATests:
-    def test_nat(self, index_without_na):
-        empty_index = index_without_na[:0]
-
-        index_with_na = index_without_na.copy(deep=True)
-        index_with_na._data[1] = NaT
-
-        assert empty_index._na_value is NaT
-        assert index_with_na._na_value is NaT
-        assert index_without_na._na_value is NaT
-
-        idx = index_without_na
-        assert idx._can_hold_na
-
-        tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
-        assert idx.hasnans is False
-
-        idx = index_with_na
-        assert idx._can_hold_na
-
-        tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
-        assert idx.hasnans is True
+@pytest.mark.parameterize(
+    "index_without_na",
+    [
+        TimedeltaIndex(["1 days", "2 days"]),
+        PeriodIndex(["2011-01-01", "2011-01-02"], freq="D"),
+        DatetimeIndex(["2011-01-01", "2011-01-02"]),
+        DatetimeIndex(["2011-01-01", "2011-01-02"], tz="UTC"),
+    ],
+)
+def test_nat(self, index_without_na):
+    empty_index = index_without_na[:0]
 
+    index_with_na = index_without_na.copy(deep=True)
+    index_with_na._data[1] = NaT
 
-class TestDatetimeIndexNA(NATests):
-    @pytest.fixture
-    def index_without_na(self, tz_naive_fixture):
-        tz = tz_naive_fixture
-        return DatetimeIndex(["2011-01-01", "2011-01-02"], tz=tz)
+    assert empty_index._na_value is NaT
+    assert index_with_na._na_value is NaT
+    assert index_without_na._na_value is NaT
 
+    idx = index_without_na
+    assert idx._can_hold_na
 
-class TestTimedeltaIndexNA(NATests):
-    @pytest.fixture
-    def index_without_na(self):
-        return TimedeltaIndex(["1 days", "2 days"])
+    tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
+    assert idx.hasnans is False
 
+    idx = index_with_na
+    assert idx._can_hold_na
 
-class TestPeriodIndexNA(NATests):
-    @pytest.fixture
-    def index_without_na(self):
-        return PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+    tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
+    assert idx.hasnans is True
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 778c07b46e57c..c4bfd9c8e0c1d 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -23,11 +23,6 @@
 import pandas.core.common as com
 
 
-@pytest.fixture(params=[None, "foo"])
-def name(request):
-    return request.param
-
-
 class ConstructorTests:
     """
     Common tests for all variations of IntervalIndex construction. Input data
@@ -35,8 +30,9 @@ class ConstructorTests:
     get_kwargs_from_breaks to the expected format.
     """
 
-    @pytest.fixture(
-        params=[
+    @pytest.mark.parameterize(
+        "breaks_and_expected_subtype",
+        [
             ([3, 14, 15, 92, 653], np.int64),
             (np.arange(10, dtype="int64"), np.int64),
             (Index(np.arange(-10, 11, dtype=np.int64)), np.int64),
@@ -48,11 +44,9 @@ class ConstructorTests:
                 "datetime64[ns, US/Eastern]",
             ),
             (timedelta_range("1 day", periods=10), "<m8[ns]"),
-        ]
+        ],
     )
-    def breaks_and_expected_subtype(self, request):
-        return request.param
-
+    @pytest.mark.parameterize("name", [None, "foo"])
     def test_constructor(self, constructor, breaks_and_expected_subtype, closed, name):
         breaks, expected_subtype = breaks_and_expected_subtype
 
@@ -372,14 +366,6 @@ def test_na_tuples(self):
 class TestClassConstructors(ConstructorTests):
     """Tests specific to the IntervalIndex/Index constructors"""
 
-    @pytest.fixture(
-        params=[IntervalIndex, partial(Index, dtype="interval")],
-        ids=["IntervalIndex", "Index"],
-    )
-    def klass(self, request):
-        # We use a separate fixture here to include Index.__new__ with dtype kwarg
-        return request.param
-
     @pytest.fixture
     def constructor(self):
         return IntervalIndex
@@ -418,6 +404,11 @@ def test_constructor_string(self):
         # the interval of strings is already forbidden.
         pass
 
+    @pytest.mark.parameterize(
+        "klass",
+        [IntervalIndex, partial(Index, dtype="interval")],
+        ids=["IntervalIndex", "Index"],
+    )
     def test_constructor_errors(self, klass):
         # mismatched closed within intervals with no constructor override
         ivs = [Interval(0, 1, closed="right"), Interval(2, 3, closed="left")]
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index 45b25f2533afd..1da6da15b9255 100644
--- a/pandas/tests/indexes/interval/test_interval_tree.py
+++ b/pandas/tests/indexes/interval/test_interval_tree.py
@@ -18,11 +18,6 @@ def skipif_32bit(param):
     return pytest.param(param, marks=marks)
 
 
-@pytest.fixture(params=["int64", "float64", "uint64"])
-def dtype(request):
-    return request.param
-
-
 @pytest.fixture(params=[skipif_32bit(1), skipif_32bit(2), 10])
 def leaf_size(request):
     """
@@ -103,6 +98,7 @@ def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype
         expected_missing = np.array([0], dtype="intp")
         tm.assert_numpy_array_equal(result_missing, expected_missing)
 
+    @pytest.mark.parameterize("dtype", ["int64", "float64", "uint64"])
     def test_duplicates(self, dtype):
         left = np.array([0, 0, 0], dtype=dtype)
         tree = IntervalTree(left, left + 1)
diff --git a/pandas/tests/indexes/numeric/test_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py
index cd28d519313ed..619b207d402fc 100644
--- a/pandas/tests/indexes/numeric/test_indexing.py
+++ b/pandas/tests/indexes/numeric/test_indexing.py
@@ -17,13 +17,6 @@
 )
 
 
-@pytest.fixture
-def index_large():
-    # large values used in Index[uint64] tests where no compat needed with Int64/Float64
-    large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
-    return Index(large, dtype=np.uint64)
-
-
 class TestGetLoc:
     def test_get_loc(self):
         index = Index([0, 1, 2])
@@ -304,6 +297,10 @@ def test_get_indexer_int64(self):
         tm.assert_numpy_array_equal(indexer, expected)
 
     def test_get_indexer_uint64(self, index_large):
+        index_large = Index(
+            [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
+            dtype=np.uint64,
+        )
         target = Index(np.arange(10).astype("uint64") * 5 + 2**63)
         indexer = index_large.get_indexer(target)
         expected = np.array([0, -1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 4fd807e1827dd..81e14bcf16e22 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -15,12 +15,16 @@ def dtype(self, request):
         return request.param
 
     @pytest.fixture
-    def simple_index(self, dtype):
-        values = np.arange(5, dtype=dtype)
-        return Index(values)
+    def mixed_index(self, dtype):
+        return Index([1.5, 2, 3, 4, 5], dtype=dtype)
+
+    @pytest.fixture
+    def float_index(self, dtype):
+        return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
 
-    @pytest.fixture(
-        params=[
+    @pytest.mark.parameterize(
+        "index",
+        [
             [1.5, 2, 3, 4, 5],
             [0.0, 2.5, 5.0, 7.5, 10.0],
             [5, 4, 3, 2, 1.5],
@@ -28,17 +32,6 @@ def simple_index(self, dtype):
         ],
         ids=["mixed", "float", "mixed_dec", "float_dec"],
     )
-    def index(self, request, dtype):
-        return Index(request.param, dtype=dtype)
-
-    @pytest.fixture
-    def mixed_index(self, dtype):
-        return Index([1.5, 2, 3, 4, 5], dtype=dtype)
-
-    @pytest.fixture
-    def float_index(self, dtype):
-        return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
-
     def test_repr_roundtrip(self, index):
         tm.assert_index_equal(eval(repr(index)), index, exact=True)
 
@@ -227,8 +220,8 @@ def test_fillna_float64(self):
         exp = Index([1.0, "obj", 3.0], name="x")
         tm.assert_index_equal(idx.fillna("obj"), exp, exact=True)
 
-    def test_logical_compat(self, simple_index):
-        idx = simple_index
+    def test_logical_compat(self, dtype):
+        idx = Index(np.arange(5, dtype=dtype))
         assert idx.all() == idx.values.all()
         assert idx.any() == idx.values.any()
 
diff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py
index 376b51dd98bb1..102560852e8e4 100644
--- a/pandas/tests/indexes/numeric/test_setops.py
+++ b/pandas/tests/indexes/numeric/test_setops.py
@@ -96,7 +96,11 @@ def test_float64_index_difference(self):
         result = string_index.difference(float_index)
         tm.assert_index_equal(result, string_index)
 
-    def test_intersection_uint64_outside_int64_range(self, index_large):
+    def test_intersection_uint64_outside_int64_range(self):
+        index_large = Index(
+            [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
+            dtype=np.uint64,
+        )
         other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20])
         result = index_large.intersection(other)
         expected = Index(np.sort(np.intersect1d(index_large.values, other.values)))
diff --git a/pandas/tests/indexing/multiindex/test_loc.py b/pandas/tests/indexing/multiindex/test_loc.py
index 5508153322adb..de7d644698f2c 100644
--- a/pandas/tests/indexing/multiindex/test_loc.py
+++ b/pandas/tests/indexing/multiindex/test_loc.py
@@ -16,14 +16,6 @@
 import pandas._testing as tm
 
 
-@pytest.fixture
-def single_level_multiindex():
-    """single level MultiIndex"""
-    return MultiIndex(
-        levels=[["foo", "bar", "baz", "qux"]], codes=[[0, 1, 2, 3]], names=["first"]
-    )
-
-
 @pytest.fixture
 def frame_random_data_integer_multi_index():
     levels = [[0, 1], [0, 1, 2]]
@@ -277,8 +269,10 @@ def test_loc_multiindex_incomplete(self):
         result = s.loc[2:4:2, "a":"c"]
         tm.assert_series_equal(result, expected)
 
-    def test_get_loc_single_level(self, single_level_multiindex):
-        single_level = single_level_multiindex
+    def test_get_loc_single_level(self):
+        single_level = MultiIndex(
+            levels=[["foo", "bar", "baz", "qux"]], codes=[[0, 1, 2, 3]], names=["first"]
+        )
         s = Series(
             np.random.default_rng(2).standard_normal(len(single_level)),
             index=single_level,
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 15c2b8d000b37..710e7652358aa 100644
--- a/pandas/tests/interchange/test_impl.py
+++ b/pandas/tests/interchange/test_impl.py
@@ -21,29 +21,12 @@
 from pandas.core.interchange.utils import ArrowCTypes
 
 
-@pytest.fixture
-def data_categorical():
-    return {
+@pytest.mark.parametrize("data", [("ordered", True), ("unordered", False)])
+def test_categorical_dtype(data):
+    data_categorical = {
         "ordered": pd.Categorical(list("testdata") * 30, ordered=True),
         "unordered": pd.Categorical(list("testdata") * 30, ordered=False),
     }
-
-
-@pytest.fixture
-def string_data():
-    return {
-        "separator data": [
-            "abC|DeF,Hik",
-            "234,3245.67",
-            "gSaf,qWer|Gre",
-            "asd3,4sad|",
-            np.nan,
-        ]
-    }
-
-
-@pytest.mark.parametrize("data", [("ordered", True), ("unordered", False)])
-def test_categorical_dtype(data, data_categorical):
     df = pd.DataFrame({"A": (data_categorical[data[0]])})
 
     col = df.__dataframe__().get_column_by_name("A")
@@ -231,7 +214,16 @@ def test_mixed_missing():
         assert df2.get_column_by_name(col_name).null_count == 2
 
 
-def test_string(string_data):
+def test_string():
+    string_data = {
+        "separator data": [
+            "abC|DeF,Hik",
+            "234,3245.67",
+            "gSaf,qWer|Gre",
+            "asd3,4sad|",
+            np.nan,
+        ]
+    }
     test_str_data = string_data["separator data"] + [""]
     df = pd.DataFrame({"A": test_str_data})
     col = df.__dataframe__().get_column_by_name("A")
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index a4021311fc963..8933fe7fcd7f8 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -27,21 +27,6 @@ def dirpath(datapath):
     return datapath("io", "data", "orc")
 
 
-@pytest.fixture(
-    params=[
-        np.array([1, 20], dtype="uint64"),
-        pd.Series(["a", "b", "a"], dtype="category"),
-        [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)],
-        [pd.Period("2022-01-03", freq="D"), pd.Period("2022-01-04", freq="D")],
-    ]
-)
-def orc_writer_dtypes_not_supported(request):
-    # Examples of dataframes with dtypes for which conversion to ORC
-    # hasn't been implemented yet, that is, Category, unsigned integers,
-    # interval, period and sparse.
-    return pd.DataFrame({"unimpl": request.param})
-
-
 def test_orc_reader_empty(dirpath):
     columns = [
         "boolean1",
@@ -294,14 +279,24 @@ def test_orc_roundtrip_bytesio():
     tm.assert_equal(expected, got)
 
 
+@pytest.mark.parameterize(
+    "orc_writer_dtypes_not_supported",
+    [
+        np.array([1, 20], dtype="uint64"),
+        pd.Series(["a", "b", "a"], dtype="category"),
+        [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)],
+        [pd.Period("2022-01-03", freq="D"), pd.Period("2022-01-04", freq="D")],
+    ],
+)
 def test_orc_writer_dtypes_not_supported(orc_writer_dtypes_not_supported):
     # GH44554
     # PyArrow gained ORC write support with the current argument order
     pytest.importorskip("pyarrow")
 
+    df = pd.DataFrame({"unimpl": orc_writer_dtypes_not_supported})
     msg = "The dtype of one or more columns is not supported yet."
     with pytest.raises(NotImplementedError, match=msg):
-        orc_writer_dtypes_not_supported.to_orc()
+        df.to_orc()
 
 
 def test_orc_dtype_backend_pyarrow():
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 51ce73ef54300..c0bc82195990a 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -9,7 +9,6 @@
 import pytest
 
 from pandas.errors import IntCastingNaNError
-import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
@@ -261,46 +260,23 @@ def __radd__(self, other):
     assert right + left is left
 
 
-@pytest.fixture(
-    params=[
-        "memoryview",
-        "array",
-        pytest.param("dask", marks=td.skip_if_no("dask.array")),
-        pytest.param("xarray", marks=td.skip_if_no("xarray")),
-    ]
-)
-def array_likes(request):
-    """
-    Fixture giving a numpy array and a parametrized 'data' object, which can
-    be a memoryview, array, dask or xarray object created from the numpy array.
-    """
-    # GH#24539 recognize e.g xarray, dask, ...
-    arr = np.array([1, 2, 3], dtype=np.int64)
-
-    name = request.param
-    if name == "memoryview":
-        data = memoryview(arr)
-    elif name == "array":
-        data = array.array("i", arr)
-    elif name == "dask":
-        import dask.array
-
-        data = dask.array.array(arr)
-    elif name == "xarray":
-        import xarray as xr
-
-        data = xr.DataArray(arr)
-
-    return arr, data
-
-
 @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
-def test_from_obscure_array(dtype, array_likes):
+@pytest.mark.parametrize("box", [memoryview, array.array, "dask", "xarray"])
+def test_from_obscure_array(dtype, box):
     # GH#24539 recognize e.g xarray, dask, ...
     # Note: we dont do this for PeriodArray bc _from_sequence won't accept
     #  an array of integers
     # TODO: could check with arraylike of Period objects
-    arr, data = array_likes
+    # GH#24539 recognize e.g xarray, dask, ...
+    arr = np.array([1, 2, 3], dtype=np.int64)
+    if box == "dask":
+        da = pytest.importorskip("dask.array")
+        data = da.array(arr)
+    elif box == "xarray":
+        xr = pytest.importorskip("xarray")
+        data = xr.DataArray(arr)
+    else:
+        data = box(arr)
 
     cls = {"M8[ns]": DatetimeArray, "m8[ns]": TimedeltaArray}[dtype]
 

From 062d047a68f7d05bb1e89680f3bc9ec609928e30 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Sat, 23 Dec 2023 21:28:11 -0800
Subject: [PATCH 04/12] Revert "Use less idx fixture in multi"

This reverts commit e4f81bb3aff832bc1f23a109624b792e5f08f6e2.
---
 pandas/tests/indexes/multi/test_analytics.py  | 17 ++++-----
 pandas/tests/indexes/multi/test_astype.py     |  7 ++--
 pandas/tests/indexes/multi/test_compat.py     |  6 ++--
 .../tests/indexes/multi/test_constructors.py  |  3 +-
 pandas/tests/indexes/multi/test_conversion.py |  3 +-
 pandas/tests/indexes/multi/test_copy.py       |  9 ++---
 pandas/tests/indexes/multi/test_duplicates.py | 10 ++----
 .../tests/indexes/multi/test_equivalence.py   | 21 +++++------
 pandas/tests/indexes/multi/test_formats.py    |  6 ++--
 pandas/tests/indexes/multi/test_get_set.py    |  3 +-
 pandas/tests/indexes/multi/test_integrity.py  | 17 ++++-----
 pandas/tests/indexes/multi/test_join.py       |  3 +-
 pandas/tests/indexes/multi/test_missing.py    | 10 +++---
 pandas/tests/indexes/multi/test_reindex.py    | 10 ++----
 pandas/tests/indexes/multi/test_reshape.py    | 18 +++-------
 pandas/tests/indexes/multi/test_setops.py     | 36 ++++++-------------
 pandas/tests/indexes/multi/test_sorting.py    | 31 ++++++++++++----
 pandas/tests/indexes/multi/test_take.py       |  6 +---
 18 files changed, 83 insertions(+), 133 deletions(-)

diff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py
index a0e7510fbe2dc..87f1439db5fc8 100644
--- a/pandas/tests/indexes/multi/test_analytics.py
+++ b/pandas/tests/indexes/multi/test_analytics.py
@@ -11,15 +11,13 @@
 import pandas._testing as tm
 
 
-def test_infer_objects():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_infer_objects(idx):
     with pytest.raises(NotImplementedError, match="to_frame"):
         idx.infer_objects()
 
 
-def test_shift():
+def test_shift(idx):
     # GH8083 test the base class for shift
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = (
         "This method is only implemented for DatetimeIndex, PeriodIndex and "
         "TimedeltaIndex; Got type MultiIndex"
@@ -78,9 +76,8 @@ def test_truncate_multiindex():
 # TODO: reshape
 
 
-def test_reorder_levels():
+def test_reorder_levels(idx):
     # this blows up
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with pytest.raises(IndexError, match="^Too many levels"):
         idx.reorder_levels([2, 1, 0])
 
@@ -177,9 +174,9 @@ def test_sub(idx):
         first.tolist() - idx[-3:]
 
 
-def test_map():
+def test_map(idx):
     # callable
-    index = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+    index = idx
 
     result = index.map(lambda x: x)
     tm.assert_index_equal(result, index)
@@ -238,11 +235,10 @@ def test_map_dictlike(idx, mapper):
     ],
     ids=lambda func: func.__name__,
 )
-def test_numpy_ufuncs(func):
+def test_numpy_ufuncs(idx, func):
     # test ufuncs of numpy. see:
     # https://numpy.org/doc/stable/reference/ufuncs.html
 
-    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     expected_exception = TypeError
     msg = (
         "loop of ufunc does not support argument 0 of type tuple which "
@@ -258,7 +254,6 @@ def test_numpy_ufuncs(func):
     ids=lambda func: func.__name__,
 )
 def test_numpy_type_funcs(idx, func):
-    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     msg = (
         f"ufunc '{func.__name__}' not supported for the input types, and the inputs "
         "could not be safely coerced to any supported types according to "
diff --git a/pandas/tests/indexes/multi/test_astype.py b/pandas/tests/indexes/multi/test_astype.py
index 1f9f8d91ad970..29908537fbe59 100644
--- a/pandas/tests/indexes/multi/test_astype.py
+++ b/pandas/tests/indexes/multi/test_astype.py
@@ -3,12 +3,10 @@
 
 from pandas.core.dtypes.dtypes import CategoricalDtype
 
-from pandas import MultiIndex
 import pandas._testing as tm
 
 
-def test_astype():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]], names=["foo"])
+def test_astype(idx):
     expected = idx.copy()
     actual = idx.astype("O")
     tm.assert_copy(actual.levels, expected.levels)
@@ -20,8 +18,7 @@ def test_astype():
 
 
 @pytest.mark.parametrize("ordered", [True, False])
-def test_astype_category(ordered):
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_astype_category(idx, ordered):
     # GH 18630
     msg = "> 1 ndim Categorical are not supported at this time"
     with pytest.raises(NotImplementedError, match=msg):
diff --git a/pandas/tests/indexes/multi/test_compat.py b/pandas/tests/indexes/multi/test_compat.py
index 4bc73f8272d08..27a8c6e9b7158 100644
--- a/pandas/tests/indexes/multi/test_compat.py
+++ b/pandas/tests/indexes/multi/test_compat.py
@@ -6,8 +6,7 @@
 import pandas._testing as tm
 
 
-def test_numeric_compat():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_numeric_compat(idx):
     with pytest.raises(TypeError, match="cannot perform __mul__"):
         idx * 1
 
@@ -30,8 +29,7 @@ def test_numeric_compat():
 
 
 @pytest.mark.parametrize("method", ["all", "any", "__invert__"])
-def test_logical_compat(method):
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_logical_compat(idx, method):
     msg = f"cannot perform {method}"
 
     with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 0ad8831805087..8456e6a7acba5 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -385,8 +385,7 @@ def test_from_tuples_empty():
     tm.assert_index_equal(result, expected)
 
 
-def test_from_tuples_index_values():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_from_tuples_index_values(idx):
     result = MultiIndex.from_tuples(idx)
     assert (result.values == idx.values).all()
 
diff --git a/pandas/tests/indexes/multi/test_conversion.py b/pandas/tests/indexes/multi/test_conversion.py
index 0109d67cb7dde..3c2ca045d6f99 100644
--- a/pandas/tests/indexes/multi/test_conversion.py
+++ b/pandas/tests/indexes/multi/test_conversion.py
@@ -9,8 +9,7 @@
 import pandas._testing as tm
 
 
-def test_to_numpy():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_to_numpy(idx):
     result = idx.to_numpy()
     exp = idx.values
     tm.assert_numpy_array_equal(result, exp)
diff --git a/pandas/tests/indexes/multi/test_copy.py b/pandas/tests/indexes/multi/test_copy.py
index 504496ea527cc..2e09a580f9528 100644
--- a/pandas/tests/indexes/multi/test_copy.py
+++ b/pandas/tests/indexes/multi/test_copy.py
@@ -26,22 +26,19 @@ def assert_multiindex_copied(copy, original):
     assert copy.sortorder == original.sortorder
 
 
-def test_copy():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_copy(idx):
     i_copy = idx.copy()
 
     assert_multiindex_copied(i_copy, idx)
 
 
-def test_shallow_copy():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_shallow_copy(idx):
     i_copy = idx._view()
 
     assert_multiindex_copied(i_copy, idx)
 
 
-def test_view():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_view(idx):
     i_view = idx.view()
     assert_multiindex_copied(i_view, idx)
 
diff --git a/pandas/tests/indexes/multi/test_duplicates.py b/pandas/tests/indexes/multi/test_duplicates.py
index faf83407cfa50..6c6d9022b1af3 100644
--- a/pandas/tests/indexes/multi/test_duplicates.py
+++ b/pandas/tests/indexes/multi/test_duplicates.py
@@ -145,19 +145,13 @@ def test_duplicate_meta_data():
         assert idx.drop_duplicates().names == idx.names
 
 
-def test_has_duplicates():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_has_duplicates(idx, idx_dup):
+    # see fixtures
     assert idx.is_unique is True
     assert idx.has_duplicates is False
-
-
-def test_has_duplicates_with_dups(idx_dup):
-    # see fixtures
     assert idx_dup.is_unique is False
     assert idx_dup.has_duplicates is True
 
-
-def test_has_duplicates_other():
     mi = MultiIndex(
         levels=[[0, 1], [0, 1, 2]], codes=[[0, 0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 0, 1, 2]]
     )
diff --git a/pandas/tests/indexes/multi/test_equivalence.py b/pandas/tests/indexes/multi/test_equivalence.py
index 079f6194c2ff9..9babbd5b8d56d 100644
--- a/pandas/tests/indexes/multi/test_equivalence.py
+++ b/pandas/tests/indexes/multi/test_equivalence.py
@@ -12,8 +12,7 @@
 import pandas._testing as tm
 
 
-def test_equals():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_equals(idx):
     assert idx.equals(idx)
     assert idx.equals(idx.copy())
     assert idx.equals(idx.astype(object))
@@ -27,6 +26,10 @@ def test_equals():
     assert idx.equals(same_values)
     assert same_values.equals(idx)
 
+    if idx.nlevels == 1:
+        # do not test MultiIndex
+        assert not idx.equals(Series(idx))
+
 
 def test_equals_op(idx):
     # GH9947, GH10637
@@ -129,8 +132,7 @@ def test_compare_tuple_strs():
     tm.assert_numpy_array_equal(result, expected)
 
 
-def test_equals_multi():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_equals_multi(idx):
     assert idx.equals(idx)
     assert not idx.equals(idx.values)
     assert idx.equals(Index(idx.values))
@@ -139,8 +141,6 @@ def test_equals_multi():
     assert not idx.equals(idx[:-1])
     assert not idx.equals(idx[-1])
 
-
-def test_equals_multi_different_levels(idx):
     # different number of levels
     index = MultiIndex(
         levels=[Index(list(range(4))), Index(list(range(4))), Index(list(range(4)))],
@@ -181,8 +181,7 @@ def test_equals_multi_different_levels(idx):
     assert not idx.equals(index)
 
 
-def test_identical():
-    idx = MultiIndex(levels=[[0, 1], [2, 3]], codes=[[0, 1], [0, 1]])
+def test_identical(idx):
     mi = idx.copy()
     mi2 = idx.copy()
     assert mi.identical(mi2)
@@ -250,14 +249,12 @@ def test_is_():
     assert not mi5.is_(mi)
 
 
-def test_is_all_dates():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_is_all_dates(idx):
     assert not idx._is_all_dates
 
 
-def test_is_numeric():
+def test_is_numeric(idx):
     # MultiIndex is never numeric
-    idx = MultiIndex(levels=[["A", "B"]], codes=[[0, 1]])
     assert not is_any_real_numeric_dtype(idx)
 
 
diff --git a/pandas/tests/indexes/multi/test_formats.py b/pandas/tests/indexes/multi/test_formats.py
index b3988e824775b..52ff3109128f2 100644
--- a/pandas/tests/indexes/multi/test_formats.py
+++ b/pandas/tests/indexes/multi/test_formats.py
@@ -9,9 +9,8 @@
 import pandas._testing as tm
 
 
-def test_format():
+def test_format(idx):
     msg = "MultiIndex.format is deprecated"
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     with tm.assert_produces_warning(FutureWarning, match=msg):
         idx.format()
         idx[:0].format()
@@ -71,9 +70,8 @@ def test_unicode_string_with_unicode():
     str(idx)
 
 
-def test_repr_max_seq_item_setting():
+def test_repr_max_seq_item_setting(idx):
     # GH10182
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     idx = idx.repeat(50)
     with pd.option_context("display.max_seq_items", None):
         repr(idx)
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index 969cbf6fb8cd9..6eeaeb6711d03 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -242,8 +242,7 @@ def test_set_codes(idx):
     assert result.equals(expected)
 
 
-def test_set_levels_codes_names_bad_input():
-    idx = MultiIndex(levels=[["A", "B"], ["B", "C"]], codes=[[0, 1], [0, 1]])
+def test_set_levels_codes_names_bad_input(idx):
     levels, codes = idx.levels, idx.codes
     names = idx.names
 
diff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py
index 93262da50b0f6..d956747cbc859 100644
--- a/pandas/tests/indexes/multi/test_integrity.py
+++ b/pandas/tests/indexes/multi/test_integrity.py
@@ -163,11 +163,10 @@ def test_take_invalid_kwargs():
         idx.take(indices, mode="clip")
 
 
-def test_isna_behavior():
+def test_isna_behavior(idx):
     # should not segfault GH5123
     # NOTE: if MI representation changes, may make sense to allow
     # isna(MI)
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         pd.isna(idx)
@@ -209,14 +208,12 @@ def test_mi_hashtable_populated_attribute_error(monkeypatch):
         df["a"].foo()
 
 
-def test_can_hold_identifiers():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_can_hold_identifiers(idx):
     key = idx[0]
     assert idx._can_hold_identifiers_and_holds_name(key) is True
 
 
-def test_metadata_immutable():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_metadata_immutable(idx):
     levels, codes = idx.levels, idx.codes
     # shouldn't be able to set at either the top level or base level
     mutable_regex = re.compile("does not support mutable operations")
@@ -268,8 +265,7 @@ def test_rangeindex_fallback_coercion_bug():
     tm.assert_index_equal(result, expected)
 
 
-def test_memory_usage():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_memory_usage(idx):
     result = idx.memory_usage()
     if len(idx):
         idx.get_loc(idx[0])
@@ -289,6 +285,5 @@ def test_memory_usage():
         assert result == 0
 
 
-def test_nlevels():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
-    assert idx.nlevels == 1
+def test_nlevels(idx):
+    assert idx.nlevels == 2
diff --git a/pandas/tests/indexes/multi/test_join.py b/pandas/tests/indexes/multi/test_join.py
index 1b88ef790723c..edd0feaaa1159 100644
--- a/pandas/tests/indexes/multi/test_join.py
+++ b/pandas/tests/indexes/multi/test_join.py
@@ -50,8 +50,7 @@ def test_join_level_corner_case(idx):
         idx.join(idx, level=1)
 
 
-def test_join_self(join_type):
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_join_self(idx, join_type):
     result = idx.join(idx, how=join_type)
     expected = idx
     if join_type == "outer":
diff --git a/pandas/tests/indexes/multi/test_missing.py b/pandas/tests/indexes/multi/test_missing.py
index 5e3c545f6a35f..14ffc42fb4b59 100644
--- a/pandas/tests/indexes/multi/test_missing.py
+++ b/pandas/tests/indexes/multi/test_missing.py
@@ -6,9 +6,8 @@
 import pandas._testing as tm
 
 
-def test_fillna():
+def test_fillna(idx):
     # GH 11343
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         idx.fillna(idx[0])
@@ -54,19 +53,18 @@ def test_dropna():
     tm.assert_index_equal(idx.dropna(how="all"), expected)
 
 
-def test_nulls():
+def test_nulls(idx):
     # this is really a smoke test for the methods
     # as these are adequately tested for function elsewhere
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+
     msg = "isna is not defined for MultiIndex"
     with pytest.raises(NotImplementedError, match=msg):
         idx.isna()
 
 
 @pytest.mark.xfail(reason="isna is not defined for MultiIndex")
-def test_hasnans_isnans():
+def test_hasnans_isnans(idx):
     # GH 11343, added tests for hasnans / isnans
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     index = idx.copy()
 
     # cases in indices doesn't include NaN
diff --git a/pandas/tests/indexes/multi/test_reindex.py b/pandas/tests/indexes/multi/test_reindex.py
index 007480db1de1b..d1b4fe8b98760 100644
--- a/pandas/tests/indexes/multi/test_reindex.py
+++ b/pandas/tests/indexes/multi/test_reindex.py
@@ -9,12 +9,7 @@
 import pandas._testing as tm
 
 
-def test_reindex():
-    idx = MultiIndex(
-        levels=[list(range(5)), list(range(1, 6))],
-        codes=[list(range(5)), list(range(5))],
-        names=["first", "second"],
-    )
+def test_reindex(idx):
     result, indexer = idx.reindex(list(idx[:4]))
     assert isinstance(result, MultiIndex)
     assert result.names == ["first", "second"]
@@ -97,8 +92,7 @@ def test_reindex_lvl_preserves_type_if_target_is_empty_list_or_array(
     assert mi.reindex([], level=1)[0].levels[1].dtype == dti.dtype
 
 
-def test_reindex_base():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_reindex_base(idx):
     expected = np.arange(idx.size, dtype=np.intp)
 
     actual = idx.get_indexer(idx)
diff --git a/pandas/tests/indexes/multi/test_reshape.py b/pandas/tests/indexes/multi/test_reshape.py
index 13d5bd1ae8d65..06dbb33aadf97 100644
--- a/pandas/tests/indexes/multi/test_reshape.py
+++ b/pandas/tests/indexes/multi/test_reshape.py
@@ -12,12 +12,7 @@
 import pandas._testing as tm
 
 
-def test_insert():
-    idx = MultiIndex(
-        levels=[["bar", "foo"], ["two", "one"]],
-        codes=[[0, 1], [0, 1]],
-        names=["first", "second"],
-    )
+def test_insert(idx):
     # key contained in all levels
     new_index = idx.insert(0, ("bar", "two"))
     assert new_index.equal_levels(idx)
@@ -39,8 +34,6 @@ def test_insert():
     with pytest.raises(ValueError, match=msg):
         idx.insert(0, ("foo2",))
 
-
-def test_insert_reindex():
     left = pd.DataFrame([["a", "b", 0], ["b", "d", 1]], columns=["1st", "2nd", "3rd"])
     left.set_index(["1st", "2nd"], inplace=True)
     ts = left["3rd"].copy(deep=True)
@@ -97,8 +90,7 @@ def test_insert2():
     tm.assert_series_equal(left, right)
 
 
-def test_append():
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_append(idx):
     result = idx[:3].append(idx[3:])
     assert result.equals(idx)
 
@@ -209,16 +201,14 @@ def test_repeat():
     tm.assert_index_equal(m.repeat(reps), expected)
 
 
-def test_insert_base():
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_insert_base(idx):
     result = idx[1:4]
 
     # test 0th element
     assert idx[0:4].equals(result.insert(0, idx[0]))
 
 
-def test_delete_base():
-    idx = MultiIndex(levels=[list(range(6))], codes=[list(range(6))])
+def test_delete_base(idx):
     expected = idx[1:]
     result = idx.delete(0)
     assert result.equals(expected)
diff --git a/pandas/tests/indexes/multi/test_setops.py b/pandas/tests/indexes/multi/test_setops.py
index 025381616743a..0abb56ecf9de7 100644
--- a/pandas/tests/indexes/multi/test_setops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -21,17 +21,15 @@
 @pytest.mark.parametrize(
     "method", ["intersection", "union", "difference", "symmetric_difference"]
 )
-def test_set_ops_error_cases(case, sort, method):
+def test_set_ops_error_cases(idx, case, sort, method):
     # non-iterable input
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "Input must be Index or array-like"
     with pytest.raises(TypeError, match=msg):
         getattr(idx, method)(case, sort=sort)
 
 
 @pytest.mark.parametrize("klass", [MultiIndex, np.array, Series, list])
-def test_intersection_base(sort, klass):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_intersection_base(idx, sort, klass):
     first = idx[2::-1]  # first 3 elements reversed
     second = idx[:5]
 
@@ -52,8 +50,7 @@ def test_intersection_base(sort, klass):
 
 @pytest.mark.arm_slow
 @pytest.mark.parametrize("klass", [MultiIndex, np.array, Series, list])
-def test_union_base(sort, klass):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_union_base(idx, sort, klass):
     first = idx[::-1]
     second = idx[:5]
 
@@ -72,8 +69,7 @@ def test_union_base(sort, klass):
         first.union([1, 2, 3], sort=sort)
 
 
-def test_difference_base(sort):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_difference_base(idx, sort):
     second = idx[4:]
     answer = idx[:4]
     result = idx.difference(second, sort=sort)
@@ -95,8 +91,7 @@ def test_difference_base(sort):
         idx.difference([1, 2, 3], sort=sort)
 
 
-def test_symmetric_difference(sort):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_symmetric_difference(idx, sort):
     first = idx[1:]
     second = idx[:-1]
     answer = idx[[-1, 0]]
@@ -129,18 +124,13 @@ def test_multiindex_symmetric_difference():
     assert result.names == [None, None]
 
 
-def test_empty():
+def test_empty(idx):
     # GH 15270
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     assert not idx.empty
     assert idx[:0].empty
 
 
-def test_difference(sort):
-    idx = MultiIndex(
-        levels=[list(range(5)), list(range(1, 6))],
-        codes=[list(range(5)), list(range(5))],
-    )
+def test_difference(idx, sort):
     first = idx
     result = first.difference(idx[-3:], sort=sort)
     vals = idx[:-3].values
@@ -247,8 +237,7 @@ def test_difference_sort_incomparable_true():
         idx.difference(other, sort=True)
 
 
-def test_union(sort):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_union(idx, sort):
     piece1 = idx[:5][::-1]
     piece2 = idx[3:]
 
@@ -293,8 +282,7 @@ def test_union_with_regular_index(idx, using_infer_string):
         assert not result.equals(result2)
 
 
-def test_intersection(sort):
-    idx = MultiIndex(levels=[list(range(5))], codes=[list(range(5))])
+def test_intersection(idx, sort):
     piece1 = idx[:5][::-1]
     piece2 = idx[3:]
 
@@ -322,8 +310,7 @@ def test_intersection(sort):
 @pytest.mark.parametrize(
     "method", ["intersection", "union", "difference", "symmetric_difference"]
 )
-def test_setop_with_categorical(sort, method):
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_setop_with_categorical(idx, sort, method):
     other = idx.to_flat_index().astype("category")
     res_names = [None] * idx.nlevels
 
@@ -336,8 +323,7 @@ def test_setop_with_categorical(sort, method):
     tm.assert_index_equal(result, expected)
 
 
-def test_intersection_non_object(sort):
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_intersection_non_object(idx, sort):
     other = Index(range(3), name="foo")
 
     result = idx.intersection(other, sort=sort)
diff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py
index 4748016d2943e..b4dcef71dcf50 100644
--- a/pandas/tests/indexes/multi/test_sorting.py
+++ b/pandas/tests/indexes/multi/test_sorting.py
@@ -7,9 +7,11 @@
 )
 
 from pandas import (
+    CategoricalIndex,
     DataFrame,
     Index,
     MultiIndex,
+    RangeIndex,
     Series,
     Timestamp,
 )
@@ -17,8 +19,7 @@
 from pandas.core.indexes.frozen import FrozenList
 
 
-def test_sortlevel():
-    idx = MultiIndex(levels=[[0, 1], [1, 2]], codes=[[0, 1], [0, 1]])
+def test_sortlevel(idx):
     tuples = list(idx)
     np.random.default_rng(2).shuffle(tuples)
 
@@ -82,12 +83,31 @@ def test_sortlevel_na_position():
     tm.assert_index_equal(result, expected)
 
 
-def test_numpy_argsort():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_numpy_argsort(idx):
     result = np.argsort(idx)
     expected = idx.argsort()
     tm.assert_numpy_array_equal(result, expected)
 
+    # these are the only two types that perform
+    # pandas compatibility input validation - the
+    # rest already perform separate (or no) such
+    # validation via their 'values' attribute as
+    # defined in pandas.core.indexes/base.py - they
+    # cannot be changed at the moment due to
+    # backwards compatibility concerns
+    if isinstance(type(idx), (CategoricalIndex, RangeIndex)):
+        msg = "the 'axis' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.argsort(idx, axis=1)
+
+        msg = "the 'kind' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.argsort(idx, kind="mergesort")
+
+        msg = "the 'order' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.argsort(idx, order=("a", "b"))
+
 
 def test_unsortedindex():
     # GH 11897
@@ -257,8 +277,7 @@ def test_remove_unused_nan(level0, level1):
         assert "unused" not in result.levels[level]
 
 
-def test_argsort():
-    idx = MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_argsort(idx):
     result = idx.argsort()
     expected = idx.values.argsort()
     tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_take.py b/pandas/tests/indexes/multi/test_take.py
index 6ae927137a304..543cba25c373b 100644
--- a/pandas/tests/indexes/multi/test_take.py
+++ b/pandas/tests/indexes/multi/test_take.py
@@ -11,17 +11,13 @@ def test_take(idx):
     expected = idx[indexer]
     assert result.equals(expected)
 
-
-def test_freq():
     # GH 10791
-    idx = pd.MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
     msg = "'MultiIndex' object has no attribute 'freq'"
     with pytest.raises(AttributeError, match=msg):
         idx.freq
 
 
-def test_take_invalid_kwargs():
-    idx = pd.MultiIndex(levels=[[0, 1]], codes=[[0, 1]])
+def test_take_invalid_kwargs(idx):
     indices = [1, 2]
 
     msg = r"take\(\) got an unexpected keyword argument 'foo'"

From e9a97c220caf8d2b3f6d8e01a44fd8ebbcab5476 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Mon, 25 Dec 2023 12:21:53 -0800
Subject: [PATCH 05/12] Remove more single use fixtures

---
 pandas/conftest.py                            |  10 -
 .../tests/indexes/interval/test_interval.py   |   6 +-
 pandas/tests/io/formats/test_format.py        |  73 +-
 .../json/test_json_table_schema_ext_dtype.py  |  22 +-
 pandas/tests/io/json/test_normalize.py        |  47 +-
 pandas/tests/io/json/test_pandas.py           |  21 +-
 pandas/tests/io/sas/test_xport.py             |  46 +-
 pandas/tests/reshape/merge/test_merge.py      | 120 +--
 pandas/tests/reshape/merge/test_merge_asof.py | 962 +++++++++---------
 pandas/tests/reshape/test_pivot.py            |  13 +-
 .../series/methods/test_convert_dtypes.py     | 339 +++---
 pandas/tests/series/methods/test_nlargest.py  |  97 +-
 pandas/tests/tools/test_to_datetime.py        |  48 +-
 pandas/tests/tseries/offsets/test_common.py   |  31 +-
 .../offsets/test_custom_business_month.py     |  56 +-
 .../util/test_assert_produces_warning.py      |  32 +-
 16 files changed, 854 insertions(+), 1069 deletions(-)

diff --git a/pandas/conftest.py b/pandas/conftest.py
index 983272d79081e..b4aaaddee75df 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1777,16 +1777,6 @@ def ip():
     return InteractiveShell(config=c)
 
 
-@pytest.fixture(params=["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
-def spmatrix(request):
-    """
-    Yields scipy sparse matrix classes.
-    """
-    sparse = pytest.importorskip("scipy.sparse")
-
-    return getattr(sparse, request.param + "_matrix")
-
-
 @pytest.fixture(
     params=[
         getattr(pd.offsets, o)
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 63f9b2176dddd..cd0bac1a7945a 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -21,11 +21,6 @@
 import pandas.core.common as com
 
 
-@pytest.fixture(params=[None, "foo"])
-def name(request):
-    return request.param
-
-
 class TestIntervalIndex:
     index = IntervalIndex.from_arrays([0, 1], [1, 2])
 
@@ -865,6 +860,7 @@ def test_nbytes(self):
         expected = 64  # 4 * 8 * 2
         assert result == expected
 
+    @pytest.mark.parametrize("name", [None, "foo"])
     @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
     def test_set_closed(self, name, closed, new_closed):
         # GH 21670
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 0ca29c219b55b..43e94b8c55589 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -4,7 +4,6 @@
 """
 from datetime import datetime
 from io import StringIO
-from pathlib import Path
 import re
 from shutil import get_terminal_size
 
@@ -32,55 +31,6 @@
 import pandas.io.formats.format as fmt
 
 
-@pytest.fixture(params=["string", "pathlike", "buffer"])
-def filepath_or_buffer_id(request):
-    """
-    A fixture yielding test ids for filepath_or_buffer testing.
-    """
-    return request.param
-
-
-@pytest.fixture
-def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
-    """
-    A fixture yielding a string representing a filepath, a path-like object
-    and a StringIO buffer. Also checks that buffer is not closed.
-    """
-    if filepath_or_buffer_id == "buffer":
-        buf = StringIO()
-        yield buf
-        assert not buf.closed
-    else:
-        assert isinstance(tmp_path, Path)
-        if filepath_or_buffer_id == "pathlike":
-            yield tmp_path / "foo"
-        else:
-            yield str(tmp_path / "foo")
-
-
-@pytest.fixture
-def assert_filepath_or_buffer_equals(
-    filepath_or_buffer, filepath_or_buffer_id, encoding
-):
-    """
-    Assertion helper for checking filepath_or_buffer.
-    """
-    if encoding is None:
-        encoding = "utf-8"
-
-    def _assert_filepath_or_buffer_equals(expected):
-        if filepath_or_buffer_id == "string":
-            with open(filepath_or_buffer, encoding=encoding) as f:
-                result = f.read()
-        elif filepath_or_buffer_id == "pathlike":
-            result = filepath_or_buffer.read_text(encoding=encoding)
-        elif filepath_or_buffer_id == "buffer":
-            result = filepath_or_buffer.getvalue()
-        assert result == expected
-
-    return _assert_filepath_or_buffer_equals
-
-
 def has_info_repr(df):
     r = repr(df)
     c1 = r.split("\n")[0].startswith("<class")
@@ -2258,14 +2208,21 @@ def test_format_percentiles_integer_idx(self):
     "encoding, data",
     [(None, "abc"), ("utf-8", "abc"), ("gbk", "造成输出中文显示乱码"), ("foo", "abc")],
 )
+@pytest.mark.parametrize("filepath_or_buffer_id", ["string", "pathlike", "buffer"])
 def test_filepath_or_buffer_arg(
     method,
-    filepath_or_buffer,
-    assert_filepath_or_buffer_equals,
+    tmp_path,
     encoding,
     data,
     filepath_or_buffer_id,
 ):
+    if filepath_or_buffer_id == "buffer":
+        filepath_or_buffer = StringIO()
+    elif filepath_or_buffer_id == "pathlike":
+        filepath_or_buffer = tmp_path / "foo"
+    else:
+        filepath_or_buffer = str(tmp_path / "foo")
+
     df = DataFrame([data])
     if method in ["to_latex"]:  # uses styler implementation
         pytest.importorskip("jinja2")
@@ -2281,7 +2238,17 @@ def test_filepath_or_buffer_arg(
     else:
         expected = getattr(df, method)()
         getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
-        assert_filepath_or_buffer_equals(expected)
+        encoding = encoding or "utf-8"
+        if filepath_or_buffer_id == "string":
+            with open(filepath_or_buffer, encoding=encoding) as f:
+                result = f.read()
+        elif filepath_or_buffer_id == "pathlike":
+            result = filepath_or_buffer.read_text(encoding=encoding)
+        elif filepath_or_buffer_id == "buffer":
+            result = filepath_or_buffer.getvalue()
+        assert result == expected
+    if filepath_or_buffer_id == "buffer":
+        assert not filepath_or_buffer.closed
 
 
 @pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
diff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
index b7bb057bc538e..015b27d0b3606 100644
--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
@@ -132,17 +132,6 @@ def sa(self):
     def ia(self):
         return array([10], dtype="Int64")
 
-    @pytest.fixture
-    def df(self, da, dc, sa, ia):
-        return DataFrame(
-            {
-                "A": da,
-                "B": dc,
-                "C": sa,
-                "D": ia,
-            }
-        )
-
     def test_build_date_series(self, da):
         s = Series(da, name="a")
         s.index.name = "id"
@@ -243,8 +232,15 @@ def test_build_int64_series(self, ia):
 
         assert result == expected
 
-    def test_to_json(self, df):
-        df = df.copy()
+    def test_to_json(self, da, dc, sa, ia):
+        df = DataFrame(
+            {
+                "A": da,
+                "B": dc,
+                "C": sa,
+                "D": ia,
+            }
+        )
         df.index.name = "idx"
         result = df.to_json(orient="table", date_format="iso")
         result = json.loads(result, object_pairs_hook=OrderedDict)
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index 3c6517a872b76..4ef288d5fae27 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -78,17 +78,6 @@ def state_data():
     ]
 
 
-@pytest.fixture
-def author_missing_data():
-    return [
-        {"info": None},
-        {
-            "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
-            "author_name": {"first": "Jane", "last_name": "Doe"},
-        },
-    ]
-
-
 @pytest.fixture
 def missing_metadata():
     return [
@@ -120,23 +109,6 @@ def missing_metadata():
     ]
 
 
-@pytest.fixture
-def max_level_test_input_data():
-    """
-    input data to test json_normalize with max_level param
-    """
-    return [
-        {
-            "CreatedBy": {"Name": "User001"},
-            "Lookup": {
-                "TextField": "Some text",
-                "UserField": {"Id": "ID001", "Name": "Name001"},
-            },
-            "Image": {"a": "b"},
-        }
-    ]
-
-
 class TestJSONNormalize:
     def test_simple_records(self):
         recs = [
@@ -426,6 +398,13 @@ def test_non_ascii_key(self):
 
     def test_missing_field(self, author_missing_data):
         # GH20030:
+        author_missing_data = [
+            {"info": None},
+            {
+                "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+                "author_name": {"first": "Jane", "last_name": "Doe"},
+            },
+        ]
         result = json_normalize(author_missing_data)
         ex_data = [
             {
@@ -843,8 +822,18 @@ def test_nonetype_multiple_levels(self):
             ),
         ],
     )
-    def test_with_max_level(self, max_level, expected, max_level_test_input_data):
+    def test_with_max_level(self, max_level, expected):
         # GH23843: Enhanced JSON normalize
+        max_level_test_input_data = [
+            {
+                "CreatedBy": {"Name": "User001"},
+                "Lookup": {
+                    "TextField": "Some text",
+                    "UserField": {"Id": "ID001", "Name": "Name001"},
+                },
+                "Image": {"a": "b"},
+            }
+        ]
         output = nested_to_record(max_level_test_input_data, max_level=max_level)
         assert output == expected
 
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 0eefb0b52c483..961ba36e5dbd8 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -93,17 +93,6 @@ def assert_json_roundtrip_equal(result, expected, orient):
 
 
 class TestPandasContainer:
-    @pytest.fixture
-    def categorical_frame(self):
-        data = {
-            c: np.random.default_rng(i).standard_normal(30)
-            for i, c in enumerate(list("ABCD"))
-        }
-        cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
-        data["E"] = list(reversed(cat))
-        data["sort"] = np.arange(30, dtype="int64")
-        return DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
-
     @pytest.fixture
     def datetime_series(self):
         # Same as usual datetime_series, but with index freq set to None,
@@ -249,7 +238,7 @@ def test_roundtrip_str_axes(self, orient, convert_axes, dtype):
 
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_roundtrip_categorical(
-        self, request, orient, categorical_frame, convert_axes, using_infer_string
+        self, request, orient, convert_axes, using_infer_string
     ):
         # TODO: create a better frame to test with and improve coverage
         if orient in ("index", "columns"):
@@ -259,6 +248,14 @@ def test_roundtrip_categorical(
                 )
             )
 
+        data = {
+            c: np.random.default_rng(i).standard_normal(30)
+            for i, c in enumerate(list("ABCD"))
+        }
+        cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
+        data["E"] = list(reversed(cat))
+        data["sort"] = np.arange(30, dtype="int64")
+        categorical_frame = DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
         data = StringIO(categorical_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes)
 
diff --git a/pandas/tests/io/sas/test_xport.py b/pandas/tests/io/sas/test_xport.py
index 766c9c37d55b9..30ca70d7e0009 100644
--- a/pandas/tests/io/sas/test_xport.py
+++ b/pandas/tests/io/sas/test_xport.py
@@ -19,31 +19,12 @@ def numeric_as_float(data):
 
 
 class TestXport:
-    @pytest.fixture
-    def file01(self, datapath):
-        return datapath("io", "sas", "data", "DEMO_G.xpt")
-
-    @pytest.fixture
-    def file02(self, datapath):
-        return datapath("io", "sas", "data", "SSHSV1_A.xpt")
-
-    @pytest.fixture
-    def file03(self, datapath):
-        return datapath("io", "sas", "data", "DRXFCD_G.xpt")
-
-    @pytest.fixture
-    def file04(self, datapath):
-        return datapath("io", "sas", "data", "paxraw_d_short.xpt")
-
-    @pytest.fixture
-    def file05(self, datapath):
-        return datapath("io", "sas", "data", "DEMO_PUF.cpt")
-
     @pytest.mark.slow
-    def test1_basic(self, file01):
+    def test1_basic(self, datapath):
         # Tests with DEMO_G.xpt (all numeric file)
 
         # Compare to this
+        file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
         data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
 
@@ -78,10 +59,11 @@ def test1_basic(self, file01):
         data = read_sas(file01)
         tm.assert_frame_equal(data, data_csv)
 
-    def test1_index(self, file01):
+    def test1_index(self, datapath):
         # Tests with DEMO_G.xpt using index (all numeric file)
 
         # Compare to this
+        file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
         data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         data_csv = data_csv.set_index("SEQN")
         numeric_as_float(data_csv)
@@ -100,9 +82,10 @@ def test1_index(self, file01):
             data = reader.get_chunk()
         tm.assert_frame_equal(data, data_csv.iloc[0:10, :], check_index_type=False)
 
-    def test1_incremental(self, file01):
+    def test1_incremental(self, datapath):
         # Test with DEMO_G.xpt, reading full file incrementally
 
+        file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
         data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
         data_csv = data_csv.set_index("SEQN")
         numeric_as_float(data_csv)
@@ -113,9 +96,10 @@ def test1_incremental(self, file01):
 
         tm.assert_frame_equal(data, data_csv, check_index_type=False)
 
-    def test2(self, file02):
+    def test2(self, datapath):
         # Test with SSHSV1_A.xpt
 
+        file02 = datapath("io", "sas", "data", "SSHSV1_A.xpt")
         # Compare to this
         data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
@@ -123,10 +107,11 @@ def test2(self, file02):
         data = read_sas(file02)
         tm.assert_frame_equal(data, data_csv)
 
-    def test2_binary(self, file02):
+    def test2_binary(self, datapath):
         # Test with SSHSV1_A.xpt, read as a binary file
 
         # Compare to this
+        file02 = datapath("io", "sas", "data", "SSHSV1_A.xpt")
         data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
         numeric_as_float(data_csv)
 
@@ -137,31 +122,32 @@ def test2_binary(self, file02):
 
         tm.assert_frame_equal(data, data_csv)
 
-    def test_multiple_types(self, file03):
+    def test_multiple_types(self, datapath):
         # Test with DRXFCD_G.xpt (contains text and numeric variables)
 
         # Compare to this
+        file03 = datapath("io", "sas", "data", "DRXFCD_G.xpt")
         data_csv = pd.read_csv(file03.replace(".xpt", ".csv"))
 
         data = read_sas(file03, encoding="utf-8")
         tm.assert_frame_equal(data, data_csv)
 
-    def test_truncated_float_support(self, file04):
+    def test_truncated_float_support(self, datapath):
         # Test with paxraw_d_short.xpt, a shortened version of:
         # http://wwwn.cdc.gov/Nchs/Nhanes/2005-2006/PAXRAW_D.ZIP
         # This file has truncated floats (5 bytes in this case).
 
         # GH 11713
-
+        file04 = datapath("io", "sas", "data", "paxraw_d_short.xpt")
         data_csv = pd.read_csv(file04.replace(".xpt", ".csv"))
 
         data = read_sas(file04, format="xport")
         tm.assert_frame_equal(data.astype("int64"), data_csv)
 
-    def test_cport_header_found_raises(self, file05):
+    def test_cport_header_found_raises(self, datapath):
         # Test with DEMO_PUF.cpt, the beginning of puf2019_1_fall.xpt
         # from https://www.cms.gov/files/zip/puf2019.zip
         # (despite the extension, it's a cpt file)
         msg = "Header record indicates a CPORT file, which is not readable."
         with pytest.raises(ValueError, match=msg):
-            read_sas(file05, format="xport")
+            read_sas(datapath("io", "sas", "data", "DEMO_PUF.cpt"), format="xport")
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index d7a343ae9f152..140c9b96a50cb 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -44,54 +44,6 @@ def get_test_data(ngroups=8, n=50):
     return arr
 
 
-def get_series():
-    return [
-        Series([1], dtype="int64"),
-        Series([1], dtype="Int64"),
-        Series([1.23]),
-        Series(["foo"]),
-        Series([True]),
-        Series([pd.Timestamp("2018-01-01")]),
-        Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
-    ]
-
-
-def get_series_na():
-    return [
-        Series([np.nan], dtype="Int64"),
-        Series([np.nan], dtype="float"),
-        Series([np.nan], dtype="object"),
-        Series([pd.NaT]),
-    ]
-
-
-@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
-def series_of_dtype(request):
-    """
-    A parametrized fixture returning a variety of Series of different
-    dtypes
-    """
-    return request.param
-
-
-@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
-def series_of_dtype2(request):
-    """
-    A duplicate of the series_of_dtype fixture, so that it can be used
-    twice by a single function
-    """
-    return request.param
-
-
-@pytest.fixture(params=get_series_na(), ids=lambda x: x.dtype.name)
-def series_of_dtype_all_na(request):
-    """
-    A parametrized fixture returning a variety of Series with all NA
-    values
-    """
-    return request.param
-
-
 @pytest.fixture
 def dfs_for_indicator():
     df1 = DataFrame({"col1": [0, 1], "col_conflict": [1, 2], "col_left": ["a", "b"]})
@@ -140,13 +92,6 @@ def left(self):
             }
         )
 
-    @pytest.fixture
-    def right(self):
-        return DataFrame(
-            {"v2": np.random.default_rng(2).standard_normal(4)},
-            index=["d", "b", "c", "a"],
-        )
-
     def test_merge_inner_join_empty(self):
         # GH 15328
         df_empty = DataFrame()
@@ -230,7 +175,11 @@ def test_merge_index_singlekey_inner(self):
         expected = left.join(right, on="key").loc[result.index]
         tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
-    def test_merge_misspecified(self, df, df2, left, right):
+    def test_merge_misspecified(self, df, df2, left):
+        right = DataFrame(
+            {"v2": np.random.default_rng(2).standard_normal(4)},
+            index=["d", "b", "c", "a"],
+        )
         msg = "Must pass right_on or right_index=True"
         with pytest.raises(pd.errors.MergeError, match=msg):
             merge(left, right, left_index=True)
@@ -572,6 +521,30 @@ def check2(exp, kwarg):
                 check1(exp_in, kwarg)
                 check2(exp_out, kwarg)
 
+    @pytest.mark.parametrize(
+        "series_of_dtype",
+        [
+            Series([1], dtype="int64"),
+            Series([1], dtype="Int64"),
+            Series([1.23]),
+            Series(["foo"]),
+            Series([True]),
+            Series([pd.Timestamp("2018-01-01")]),
+            Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "series_of_dtype2",
+        [
+            Series([1], dtype="int64"),
+            Series([1], dtype="Int64"),
+            Series([1.23]),
+            Series(["foo"]),
+            Series([True]),
+            Series([pd.Timestamp("2018-01-01")]),
+            Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+        ],
+    )
     def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
         # GH 25183
         df = DataFrame(
@@ -590,6 +563,27 @@ def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
         actual = df_empty.merge(df, on="key")
         tm.assert_frame_equal(actual, expected)
 
+    @pytest.mark.parametrize(
+        "series_of_dtype",
+        [
+            Series([1], dtype="int64"),
+            Series([1], dtype="Int64"),
+            Series([1.23]),
+            Series(["foo"]),
+            Series([True]),
+            Series([pd.Timestamp("2018-01-01")]),
+            Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "series_of_dtype_all_na",
+        [
+            Series([np.nan], dtype="Int64"),
+            Series([np.nan], dtype="float"),
+            Series([np.nan], dtype="object"),
+            Series([pd.NaT]),
+        ],
+    )
     def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
         # GH 25183
         df_left = DataFrame(
@@ -2140,16 +2134,6 @@ def test_merge_on_int_array(self):
         tm.assert_frame_equal(result, expected)
 
 
-@pytest.fixture
-def left_df():
-    return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
-
-
-@pytest.fixture
-def right_df():
-    return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
-
-
 class TestMergeOnIndexes:
     @pytest.mark.parametrize(
         "how, sort, expected",
@@ -2198,7 +2182,9 @@ class TestMergeOnIndexes:
             ),
         ],
     )
-    def test_merge_on_indexes(self, left_df, right_df, how, sort, expected):
+    def test_merge_on_indexes(self, how, sort, expected):
+        left_df = DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+        right_df = DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
         result = merge(
             left_df, right_df, left_index=True, right_index=True, how=how, sort=sort
         )
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index b656191cc739d..1676ae5814cbd 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -612,486 +612,6 @@ def tolerance(self):
         df["ask"] = df["ask"].astype("float64")
         return self.prep_data(df)
 
-    @pytest.fixture
-    def allow_exact_matches(self, datapath):
-        df = pd.DataFrame(
-            [
-                [
-                    "20160525 13:30:00.023",
-                    "MSFT",
-                    "51.95",
-                    "75",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.038",
-                    "MSFT",
-                    "51.95",
-                    "155",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.77",
-                    "100",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.92",
-                    "100",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "200",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "300",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "600",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "44",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.074",
-                    "AAPL",
-                    "98.67",
-                    "478343",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.67",
-                    "478343",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.66",
-                    "6",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "30",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "75",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "20",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "35",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "10",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
-                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "1000",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "200",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "300",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "400",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "600",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "200",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "783",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "100",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "100",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-            ],
-            columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
-        )
-        df["price"] = df["price"].astype("float64")
-        df["quantity"] = df["quantity"].astype("int64")
-        df["bid"] = df["bid"].astype("float64")
-        df["ask"] = df["ask"].astype("float64")
-        return self.prep_data(df)
-
-    @pytest.fixture
-    def allow_exact_matches_and_tolerance(self):
-        df = pd.DataFrame(
-            [
-                [
-                    "20160525 13:30:00.023",
-                    "MSFT",
-                    "51.95",
-                    "75",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.038",
-                    "MSFT",
-                    "51.95",
-                    "155",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.77",
-                    "100",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.92",
-                    "100",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "200",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "300",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "600",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.048",
-                    "GOOG",
-                    "720.93",
-                    "44",
-                    "NASDAQ",
-                    "720.5",
-                    "720.93",
-                ],
-                [
-                    "20160525 13:30:00.074",
-                    "AAPL",
-                    "98.67",
-                    "478343",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.67",
-                    "478343",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.66",
-                    "6",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "30",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "75",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "20",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "35",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                [
-                    "20160525 13:30:00.075",
-                    "AAPL",
-                    "98.65",
-                    "10",
-                    "NASDAQ",
-                    np.nan,
-                    np.nan,
-                ],
-                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
-                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "1000",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "200",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "300",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "400",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "600",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.076",
-                    "AAPL",
-                    "98.56",
-                    "200",
-                    "ARCA",
-                    "98.55",
-                    "98.56",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "783",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "100",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-                [
-                    "20160525 13:30:00.078",
-                    "MSFT",
-                    "51.95",
-                    "100",
-                    "NASDAQ",
-                    "51.95",
-                    "51.95",
-                ],
-            ],
-            columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
-        )
-        df["price"] = df["price"].astype("float64")
-        df["quantity"] = df["quantity"].astype("int64")
-        df["bid"] = df["bid"].astype("float64")
-        df["ask"] = df["ask"].astype("float64")
-        return self.prep_data(df)
-
     def test_examples1(self):
         """doc-string examples"""
         left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
@@ -2628,11 +2148,247 @@ def test_index_tolerance(self, trades, quotes, tolerance):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_allow_exact_matches(self, trades, quotes, allow_exact_matches):
+    def test_allow_exact_matches(self, trades, quotes):
         result = merge_asof(
             trades, quotes, on="time", by="ticker", allow_exact_matches=False
         )
-        expected = allow_exact_matches
+        df = pd.DataFrame(
+            [
+                [
+                    "20160525 13:30:00.023",
+                    "MSFT",
+                    "51.95",
+                    "75",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.038",
+                    "MSFT",
+                    "51.95",
+                    "155",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.77",
+                    "100",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.92",
+                    "100",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "200",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "300",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "600",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "44",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.074",
+                    "AAPL",
+                    "98.67",
+                    "478343",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.67",
+                    "478343",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.66",
+                    "6",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "30",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "75",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "20",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "35",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "10",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "1000",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "200",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "300",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "400",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "600",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "200",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "783",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "100",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "100",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+            ],
+            columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
+        )
+        df["price"] = df["price"].astype("float64")
+        df["quantity"] = df["quantity"].astype("int64")
+        df["bid"] = df["bid"].astype("float64")
+        df["ask"] = df["ask"].astype("float64")
+        expected = self.prep_data(df)
         tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_forward(self):
@@ -2665,9 +2421,7 @@ def test_allow_exact_matches_nearest(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_allow_exact_matches_and_tolerance(
-        self, trades, quotes, allow_exact_matches_and_tolerance
-    ):
+    def test_allow_exact_matches_and_tolerance(self, trades, quotes):
         result = merge_asof(
             trades,
             quotes,
@@ -2676,7 +2430,243 @@ def test_allow_exact_matches_and_tolerance(
             tolerance=Timedelta("100ms"),
             allow_exact_matches=False,
         )
-        expected = allow_exact_matches_and_tolerance
+        df = pd.DataFrame(
+            [
+                [
+                    "20160525 13:30:00.023",
+                    "MSFT",
+                    "51.95",
+                    "75",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.038",
+                    "MSFT",
+                    "51.95",
+                    "155",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.77",
+                    "100",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.92",
+                    "100",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "200",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "300",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "600",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.048",
+                    "GOOG",
+                    "720.93",
+                    "44",
+                    "NASDAQ",
+                    "720.5",
+                    "720.93",
+                ],
+                [
+                    "20160525 13:30:00.074",
+                    "AAPL",
+                    "98.67",
+                    "478343",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.67",
+                    "478343",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.66",
+                    "6",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "30",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "75",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "20",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "35",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                [
+                    "20160525 13:30:00.075",
+                    "AAPL",
+                    "98.65",
+                    "10",
+                    "NASDAQ",
+                    np.nan,
+                    np.nan,
+                ],
+                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+                ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "1000",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "200",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "300",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "400",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "600",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.076",
+                    "AAPL",
+                    "98.56",
+                    "200",
+                    "ARCA",
+                    "98.55",
+                    "98.56",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "783",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "100",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+                [
+                    "20160525 13:30:00.078",
+                    "MSFT",
+                    "51.95",
+                    "100",
+                    "NASDAQ",
+                    "51.95",
+                    "51.95",
+                ],
+            ],
+            columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
+        )
+        df["price"] = df["price"].astype("float64")
+        df["quantity"] = df["quantity"].astype("int64")
+        df["bid"] = df["bid"].astype("float64")
+        df["ask"] = df["ask"].astype("float64")
+        expected = self.prep_data(df)
         tm.assert_frame_equal(result, expected)
 
     def test_allow_exact_matches_and_tolerance2(self):
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 18a449b4d0c67..849d602033113 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -35,12 +35,6 @@ def dropna(request):
     return request.param
 
 
-@pytest.fixture(params=[([0] * 4, [1] * 4), (range(3), range(1, 4))])
-def interval_values(request, closed):
-    left, right = request.param
-    return Categorical(pd.IntervalIndex.from_arrays(left, right, closed))
-
-
 class TestPivotTable:
     @pytest.fixture
     def data(self):
@@ -308,8 +302,13 @@ def test_pivot_with_non_observable_dropna_multi_cat(self, dropna):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_pivot_with_interval_index(self, interval_values, dropna):
+    @pytest.mark.parametrize(
+        "left_right", [([0] * 4, [1] * 4), (range(3), range(1, 4))]
+    )
+    def test_pivot_with_interval_index(self, left_right, dropna, closed):
         # GH 25814
+        left, right = left_right
+        interval_values = Categorical(pd.IntervalIndex.from_arrays(left, right, closed))
         df = DataFrame({"A": interval_values, "B": 1})
 
         msg = "The default value of observed=False is deprecated"
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index b0a920ba02cad..f6f3a3b0fb07e 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -8,187 +8,180 @@
 import pandas as pd
 import pandas._testing as tm
 
-# Each test case consists of a tuple with the data and dtype to create the
-# test Series, the default dtype for the expected result (which is valid
-# for most cases), and the specific cases where the result deviates from
-# this default. Those overrides are defined as a dict with (keyword, val) as
-# dictionary key. In case of multiple items, the last override takes precedence.
-
-
-@pytest.fixture(
-    params=[
-        (
-            # data
-            [1, 2, 3],
-            # original dtype
-            np.dtype("int32"),
-            # default expected dtype
-            "Int32",
-            # exceptions on expected dtype
-            {("convert_integer", False): np.dtype("int32")},
-        ),
-        (
-            [1, 2, 3],
-            np.dtype("int64"),
-            "Int64",
-            {("convert_integer", False): np.dtype("int64")},
-        ),
-        (
-            ["x", "y", "z"],
-            np.dtype("O"),
-            pd.StringDtype(),
-            {("convert_string", False): np.dtype("O")},
-        ),
-        (
-            [True, False, np.nan],
-            np.dtype("O"),
-            pd.BooleanDtype(),
-            {("convert_boolean", False): np.dtype("O")},
-        ),
-        (
-            ["h", "i", np.nan],
-            np.dtype("O"),
-            pd.StringDtype(),
-            {("convert_string", False): np.dtype("O")},
-        ),
-        (  # GH32117
-            ["h", "i", 1],
-            np.dtype("O"),
-            np.dtype("O"),
-            {},
-        ),
-        (
-            [10, np.nan, 20],
-            np.dtype("float"),
-            "Int64",
-            {
-                ("convert_integer", False, "convert_floating", True): "Float64",
-                ("convert_integer", False, "convert_floating", False): np.dtype(
-                    "float"
-                ),
-            },
-        ),
-        (
-            [np.nan, 100.5, 200],
-            np.dtype("float"),
-            "Float64",
-            {("convert_floating", False): np.dtype("float")},
-        ),
-        (
-            [3, 4, 5],
-            "Int8",
-            "Int8",
-            {},
-        ),
-        (
-            [[1, 2], [3, 4], [5]],
-            None,
-            np.dtype("O"),
-            {},
-        ),
-        (
-            [4, 5, 6],
-            np.dtype("uint32"),
-            "UInt32",
-            {("convert_integer", False): np.dtype("uint32")},
-        ),
-        (
-            [-10, 12, 13],
-            np.dtype("i1"),
-            "Int8",
-            {("convert_integer", False): np.dtype("i1")},
-        ),
-        (
-            [1.2, 1.3],
-            np.dtype("float32"),
-            "Float32",
-            {("convert_floating", False): np.dtype("float32")},
-        ),
-        (
-            [1, 2.0],
-            object,
-            "Int64",
-            {
-                ("convert_integer", False): "Float64",
-                ("convert_integer", False, "convert_floating", False): np.dtype(
-                    "float"
-                ),
-                ("infer_objects", False): np.dtype("object"),
-            },
-        ),
-        (
-            [1, 2.5],
-            object,
-            "Float64",
-            {
-                ("convert_floating", False): np.dtype("float"),
-                ("infer_objects", False): np.dtype("object"),
-            },
-        ),
-        (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("s"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            {},
-        ),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ms"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            {},
-        ),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("us"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            {},
-        ),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            pd.DatetimeTZDtype(tz="UTC"),
-            {},
-        ),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
-            "datetime64[ns]",
-            np.dtype("datetime64[ns]"),
-            {},
-        ),
-        (
-            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
-            object,
-            np.dtype("datetime64[ns]"),
-            {("infer_objects", False): np.dtype("object")},
-        ),
-        (
-            pd.period_range("1/1/2011", freq="M", periods=3),
-            None,
-            pd.PeriodDtype("M"),
-            {},
-        ),
-        (
-            pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
-            None,
-            pd.IntervalDtype("int64", "right"),
-            {},
-        ),
-    ]
-)
-def test_cases(request):
-    return request.param
-
 
 class TestSeriesConvertDtypes:
+    @pytest.mark.parametrize(
+        "data, maindtype, expected_default, expected_other",
+        [
+            (
+                # data
+                [1, 2, 3],
+                # original dtype
+                np.dtype("int32"),
+                # default expected dtype
+                "Int32",
+                # exceptions on expected dtype
+                {("convert_integer", False): np.dtype("int32")},
+            ),
+            (
+                [1, 2, 3],
+                np.dtype("int64"),
+                "Int64",
+                {("convert_integer", False): np.dtype("int64")},
+            ),
+            (
+                ["x", "y", "z"],
+                np.dtype("O"),
+                pd.StringDtype(),
+                {("convert_string", False): np.dtype("O")},
+            ),
+            (
+                [True, False, np.nan],
+                np.dtype("O"),
+                pd.BooleanDtype(),
+                {("convert_boolean", False): np.dtype("O")},
+            ),
+            (
+                ["h", "i", np.nan],
+                np.dtype("O"),
+                pd.StringDtype(),
+                {("convert_string", False): np.dtype("O")},
+            ),
+            (  # GH32117
+                ["h", "i", 1],
+                np.dtype("O"),
+                np.dtype("O"),
+                {},
+            ),
+            (
+                [10, np.nan, 20],
+                np.dtype("float"),
+                "Int64",
+                {
+                    ("convert_integer", False, "convert_floating", True): "Float64",
+                    ("convert_integer", False, "convert_floating", False): np.dtype(
+                        "float"
+                    ),
+                },
+            ),
+            (
+                [np.nan, 100.5, 200],
+                np.dtype("float"),
+                "Float64",
+                {("convert_floating", False): np.dtype("float")},
+            ),
+            (
+                [3, 4, 5],
+                "Int8",
+                "Int8",
+                {},
+            ),
+            (
+                [[1, 2], [3, 4], [5]],
+                None,
+                np.dtype("O"),
+                {},
+            ),
+            (
+                [4, 5, 6],
+                np.dtype("uint32"),
+                "UInt32",
+                {("convert_integer", False): np.dtype("uint32")},
+            ),
+            (
+                [-10, 12, 13],
+                np.dtype("i1"),
+                "Int8",
+                {("convert_integer", False): np.dtype("i1")},
+            ),
+            (
+                [1.2, 1.3],
+                np.dtype("float32"),
+                "Float32",
+                {("convert_floating", False): np.dtype("float32")},
+            ),
+            (
+                [1, 2.0],
+                object,
+                "Int64",
+                {
+                    ("convert_integer", False): "Float64",
+                    ("convert_integer", False, "convert_floating", False): np.dtype(
+                        "float"
+                    ),
+                    ("infer_objects", False): np.dtype("object"),
+                },
+            ),
+            (
+                [1, 2.5],
+                object,
+                "Float64",
+                {
+                    ("convert_floating", False): np.dtype("float"),
+                    ("infer_objects", False): np.dtype("object"),
+                },
+            ),
+            (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("s"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                {},
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ms"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                {},
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("us"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                {},
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                pd.DatetimeTZDtype(tz="UTC"),
+                {},
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+                "datetime64[ns]",
+                np.dtype("datetime64[ns]"),
+                {},
+            ),
+            (
+                pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+                object,
+                np.dtype("datetime64[ns]"),
+                {("infer_objects", False): np.dtype("object")},
+            ),
+            (
+                pd.period_range("1/1/2011", freq="M", periods=3),
+                None,
+                pd.PeriodDtype("M"),
+                {},
+            ),
+            (
+                pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+                None,
+                pd.IntervalDtype("int64", "right"),
+                {},
+            ),
+        ],
+    )
     @pytest.mark.parametrize("params", product(*[(True, False)] * 5))
     def test_convert_dtypes(
         self,
-        test_cases,
+        data,
+        maindtype,
+        expected_default,
+        expected_other,
         params,
         using_infer_string,
     ):
-        data, maindtype, expected_default, expected_other = test_cases
         if (
             hasattr(data, "dtype")
             and lib.is_np_dtype(data.dtype, "M")
diff --git a/pandas/tests/series/methods/test_nlargest.py b/pandas/tests/series/methods/test_nlargest.py
index e8de1cd89e397..bf13ea04ca9f9 100644
--- a/pandas/tests/series/methods/test_nlargest.py
+++ b/pandas/tests/series/methods/test_nlargest.py
@@ -2,8 +2,6 @@
 Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
 but are implicitly also testing nsmallest_foo.
 """
-from itertools import product
-
 import numpy as np
 import pytest
 
@@ -11,68 +9,6 @@
 from pandas import Series
 import pandas._testing as tm
 
-main_dtypes = [
-    "datetime",
-    "datetimetz",
-    "timedelta",
-    "int8",
-    "int16",
-    "int32",
-    "int64",
-    "float32",
-    "float64",
-    "uint8",
-    "uint16",
-    "uint32",
-    "uint64",
-]
-
-
-@pytest.fixture
-def s_main_dtypes():
-    """
-    A DataFrame with many dtypes
-
-    * datetime
-    * datetimetz
-    * timedelta
-    * [u]int{8,16,32,64}
-    * float{32,64}
-
-    The columns are the name of the dtype.
-    """
-    df = pd.DataFrame(
-        {
-            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
-            "datetimetz": pd.to_datetime(
-                ["2003", "2002", "2001", "2002", "2005"]
-            ).tz_localize("US/Eastern"),
-            "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
-        }
-    )
-
-    for dtype in [
-        "int8",
-        "int16",
-        "int32",
-        "int64",
-        "float32",
-        "float64",
-        "uint8",
-        "uint16",
-        "uint32",
-        "uint64",
-    ]:
-        df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
-
-    return df
-
-
-@pytest.fixture(params=main_dtypes)
-def s_main_dtypes_split(request, s_main_dtypes):
-    """Each series in s_main_dtypes."""
-    return s_main_dtypes[request.param]
-
 
 def assert_check_nselect_boundary(vals, dtype, method):
     # helper function for 'test_boundary_{dtype}' tests
@@ -96,19 +32,36 @@ class TestSeriesNLargestNSmallest:
             Series(list("abcde"), dtype="category"),
         ],
     )
-    def test_nlargest_error(self, r):
+    @pytest.mark.parametrize("method", ["nlargest", "nsmallest"])
+    @pytest.mark.parametrize("arg", [2, 5, 0, -1])
+    def test_nlargest_error(self, r, method, arg):
         dt = r.dtype
         msg = f"Cannot use method 'n(largest|smallest)' with dtype {dt}"
-        args = 2, len(r), 0, -1
-        methods = r.nlargest, r.nsmallest
-        for method, arg in product(methods, args):
-            with pytest.raises(TypeError, match=msg):
-                method(arg)
+        with pytest.raises(TypeError, match=msg):
+            getattr(r, method)(arg)
 
-    def test_nsmallest_nlargest(self, s_main_dtypes_split):
+    @pytest.mark.parametrize(
+        "data",
+        [
+            pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+            pd.to_datetime(["2003", "2002", "2001", "2002", "2005"], utc=True),
+            pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
+            np.array([3, 2, 1, 2, 5], dtype="int8"),
+            np.array([3, 2, 1, 2, 5], dtype="int16"),
+            np.array([3, 2, 1, 2, 5], dtype="int32"),
+            np.array([3, 2, 1, 2, 5], dtype="int64"),
+            np.array([3, 2, 1, 2, 5], dtype="uint8"),
+            np.array([3, 2, 1, 2, 5], dtype="uint16"),
+            np.array([3, 2, 1, 2, 5], dtype="uint32"),
+            np.array([3, 2, 1, 2, 5], dtype="uint64"),
+            np.array([3, 2, 1, 2, 5], dtype="float32"),
+            np.array([3, 2, 1, 2, 5], dtype="float64"),
+        ],
+    )
+    def test_nsmallest_nlargest(self, data):
         # float, int, datetime64 (use i8), timedelts64 (same),
         # object that are numbers, object that are strings
-        ser = s_main_dtypes_split
+        ser = Series(data)
 
         tm.assert_series_equal(ser.nsmallest(2), ser.iloc[[2, 1]])
         tm.assert_series_equal(ser.nsmallest(2, keep="last"), ser.iloc[[2, 3]])
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 6791ac0340640..35df1586adb4a 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -3311,37 +3311,6 @@ def units(request):
     return request.param
 
 
-@pytest.fixture
-def epoch_1960():
-    """Timestamp at 1960-01-01."""
-    return Timestamp("1960-01-01")
-
-
-@pytest.fixture
-def units_from_epochs():
-    return list(range(5))
-
-
-@pytest.fixture(params=["timestamp", "pydatetime", "datetime64", "str_1960"])
-def epochs(epoch_1960, request):
-    """Timestamp at 1960-01-01 in various forms.
-
-    * Timestamp
-    * datetime.datetime
-    * numpy.datetime64
-    * str
-    """
-    assert request.param in {"timestamp", "pydatetime", "datetime64", "str_1960"}
-    if request.param == "timestamp":
-        return epoch_1960
-    elif request.param == "pydatetime":
-        return epoch_1960.to_pydatetime()
-    elif request.param == "datetime64":
-        return epoch_1960.to_datetime64()
-    else:
-        return str(epoch_1960)
-
-
 @pytest.fixture
 def julian_dates():
     return date_range("2014-1-1", periods=10).to_julian_date().values
@@ -3399,7 +3368,18 @@ def test_invalid_origin(self, unit):
         with pytest.raises(ValueError, match=msg):
             to_datetime("2005-01-01", origin="1960-01-01", unit=unit)
 
-    def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
+    @pytest.mark.parameterize(
+        "epochs",
+        [
+            Timestamp(1960, 1, 1),
+            datetime(1960, 1, 1),
+            "1960-01-01",
+            np.datetime64("1960-01-01"),
+        ],
+    )
+    def test_epoch(self, units, epochs):
+        epoch_1960 = Timestamp(1960, 1, 1)
+        units_from_epochs = list(range(5))
         expected = Series(
             [pd.Timedelta(x, unit=units) + epoch_1960 for x in units_from_epochs]
         )
@@ -3416,7 +3396,7 @@ def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
             (datetime(1, 1, 1), OutOfBoundsDatetime),
         ],
     )
-    def test_invalid_origins(self, origin, exc, units, units_from_epochs):
+    def test_invalid_origins(self, origin, exc, units):
         msg = "|".join(
             [
                 f"origin {origin} is Out of Bounds",
@@ -3425,7 +3405,7 @@ def test_invalid_origins(self, origin, exc, units, units_from_epochs):
             ]
         )
         with pytest.raises(exc, match=msg):
-            to_datetime(units_from_epochs, unit=units, origin=origin)
+            to_datetime(list(range(5)), unit=units, origin=origin)
 
     def test_invalid_origins_tzinfo(self):
         # GH16842
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index 5b80b8b1c4ab4..51acd2f094684 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -106,15 +106,6 @@ def _offset(request):
     return request.param
 
 
-@pytest.fixture
-def dt(_offset):
-    if _offset in (CBMonthBegin, CBMonthEnd, BDay):
-        return Timestamp(2008, 1, 1)
-    elif _offset is (CustomBusinessHour, BusinessHour):
-        return Timestamp(2014, 7, 1, 10, 00)
-    return Timestamp(2008, 1, 2)
-
-
 def test_apply_out_of_range(request, tz_naive_fixture, _offset):
     tz = tz_naive_fixture
 
@@ -238,16 +229,20 @@ def test_sub(date, offset_box, offset2):
 
 
 @pytest.mark.parametrize(
-    "offset_box, offset1",
+    "offset_box, offset1, dt",
     [
-        [BDay, BDay()],
-        [LastWeekOfMonth, LastWeekOfMonth()],
-        [WeekOfMonth, WeekOfMonth()],
-        [Week, Week()],
-        [SemiMonthBegin, SemiMonthBegin()],
-        [SemiMonthEnd, SemiMonthEnd()],
-        [CustomBusinessHour, CustomBusinessHour(weekmask="Tue Wed Thu Fri")],
-        [BusinessHour, BusinessHour()],
+        [BDay, BDay(), Timestamp(2008, 1, 1)],
+        [LastWeekOfMonth, LastWeekOfMonth(), Timestamp(2008, 1, 2)],
+        [WeekOfMonth, WeekOfMonth(), Timestamp(2008, 1, 2)],
+        [Week, Week(), Timestamp(2008, 1, 2)],
+        [SemiMonthBegin, SemiMonthBegin(), Timestamp(2008, 1, 2)],
+        [SemiMonthEnd, SemiMonthEnd(), Timestamp(2008, 1, 2)],
+        [
+            CustomBusinessHour,
+            CustomBusinessHour(weekmask="Tue Wed Thu Fri"),
+            Timestamp(2014, 7, 1, 10, 00),
+        ],
+        [BusinessHour, BusinessHour(), Timestamp(2014, 7, 1, 10, 00)],
     ],
 )
 def test_Mult1(offset_box, offset1, dt):
diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py
index d226302e042d3..b74b210c3b191 100644
--- a/pandas/tests/tseries/offsets/test_custom_business_month.py
+++ b/pandas/tests/tseries/offsets/test_custom_business_month.py
@@ -62,30 +62,18 @@ def test_copy(self, _offset):
 
 
 class TestCustomBusinessMonthBegin:
-    @pytest.fixture
-    def _offset(self):
-        return CBMonthBegin
-
-    @pytest.fixture
-    def offset(self):
-        return CBMonthBegin()
-
-    @pytest.fixture
-    def offset2(self):
-        return CBMonthBegin(2)
-
-    def test_different_normalize_equals(self, _offset):
+    def test_different_normalize_equals(self):
         # GH#21404 changed __eq__ to return False when `normalize` does not match
-        offset = _offset()
-        offset2 = _offset(normalize=True)
+        offset = CBMonthBegin()
+        offset2 = CBMonthBegin(normalize=True)
         assert offset != offset2
 
-    def test_repr(self, offset, offset2):
-        assert repr(offset) == "<CustomBusinessMonthBegin>"
-        assert repr(offset2) == "<2 * CustomBusinessMonthBegins>"
+    def test_repr(self):
+        assert repr(CBMonthBegin()) == "<CustomBusinessMonthBegin>"
+        assert repr(CBMonthBegin(2)) == "<2 * CustomBusinessMonthBegins>"
 
-    def test_add_datetime(self, dt, offset2):
-        assert offset2 + dt == datetime(2008, 3, 3)
+    def test_add_datetime(self, dt):
+        assert CBMonthBegin(2) + dt == datetime(2008, 3, 3)
 
     def testRollback1(self):
         assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
@@ -252,30 +240,18 @@ def test_apply_with_extra_offset(self, case):
 
 
 class TestCustomBusinessMonthEnd:
-    @pytest.fixture
-    def _offset(self):
-        return CBMonthEnd
-
-    @pytest.fixture
-    def offset(self):
-        return CBMonthEnd()
-
-    @pytest.fixture
-    def offset2(self):
-        return CBMonthEnd(2)
-
-    def test_different_normalize_equals(self, _offset):
+    def test_different_normalize_equals(self):
         # GH#21404 changed __eq__ to return False when `normalize` does not match
-        offset = _offset()
-        offset2 = _offset(normalize=True)
+        offset = CBMonthEnd()
+        offset2 = CBMonthEnd(normalize=True)
         assert offset != offset2
 
-    def test_repr(self, offset, offset2):
-        assert repr(offset) == "<CustomBusinessMonthEnd>"
-        assert repr(offset2) == "<2 * CustomBusinessMonthEnds>"
+    def test_repr(self):
+        assert repr(CBMonthEnd()) == "<CustomBusinessMonthEnd>"
+        assert repr(CBMonthEnd(2)) == "<2 * CustomBusinessMonthEnds>"
 
-    def test_add_datetime(self, dt, offset2):
-        assert offset2 + dt == datetime(2008, 2, 29)
+    def test_add_datetime(self, dt):
+        assert CBMonthEnd(2) + dt == datetime(2008, 2, 29)
 
     def testRollback1(self):
         assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
diff --git a/pandas/tests/util/test_assert_produces_warning.py b/pandas/tests/util/test_assert_produces_warning.py
index 5c27a3ee79d4a..88e9f0d8fccee 100644
--- a/pandas/tests/util/test_assert_produces_warning.py
+++ b/pandas/tests/util/test_assert_produces_warning.py
@@ -13,26 +13,6 @@
 import pandas._testing as tm
 
 
-@pytest.fixture(
-    params=[
-        RuntimeWarning,
-        ResourceWarning,
-        UserWarning,
-        FutureWarning,
-        DeprecationWarning,
-        PerformanceWarning,
-        DtypeWarning,
-    ],
-)
-def category(request):
-    """
-    Return unique warning.
-
-    Useful for testing behavior of tm.assert_produces_warning with various categories.
-    """
-    return request.param
-
-
 @pytest.fixture(
     params=[
         (RuntimeWarning, UserWarning),
@@ -73,6 +53,18 @@ def test_assert_produces_warning_honors_filter():
         f()
 
 
+@pytest.mark.parametrize(
+    "category",
+    [
+        RuntimeWarning,
+        ResourceWarning,
+        UserWarning,
+        FutureWarning,
+        DeprecationWarning,
+        PerformanceWarning,
+        DtypeWarning,
+    ],
+)
 @pytest.mark.parametrize(
     "message, match",
     [

From c7f7813e814ddf49a0d7e8b36d5b0a7089d13368 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Mon, 25 Dec 2023 17:05:59 -0800
Subject: [PATCH 06/12] Fix typos

---
 pandas/tests/indexes/datetimelike_/test_nat.py      | 2 +-
 pandas/tests/indexes/interval/test_constructors.py  | 6 +++---
 pandas/tests/indexes/interval/test_interval_tree.py | 2 +-
 pandas/tests/indexes/numeric/test_numeric.py        | 2 +-
 pandas/tests/io/test_orc.py                         | 2 +-
 pandas/tests/tools/test_to_datetime.py              | 2 +-
 pandas/tests/tseries/offsets/test_common.py         | 3 +--
 7 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/pandas/tests/indexes/datetimelike_/test_nat.py b/pandas/tests/indexes/datetimelike_/test_nat.py
index 47a5e4638e69d..1a667536b9266 100644
--- a/pandas/tests/indexes/datetimelike_/test_nat.py
+++ b/pandas/tests/indexes/datetimelike_/test_nat.py
@@ -10,7 +10,7 @@
 import pandas._testing as tm
 
 
-@pytest.mark.parameterize(
+@pytest.mark.parametrize(
     "index_without_na",
     [
         TimedeltaIndex(["1 days", "2 days"]),
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index c4bfd9c8e0c1d..e9864723f026e 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -30,7 +30,7 @@ class ConstructorTests:
     get_kwargs_from_breaks to the expected format.
     """
 
-    @pytest.mark.parameterize(
+    @pytest.mark.parametrize(
         "breaks_and_expected_subtype",
         [
             ([3, 14, 15, 92, 653], np.int64),
@@ -46,7 +46,7 @@ class ConstructorTests:
             (timedelta_range("1 day", periods=10), "<m8[ns]"),
         ],
     )
-    @pytest.mark.parameterize("name", [None, "foo"])
+    @pytest.mark.parametrize("name", [None, "foo"])
     def test_constructor(self, constructor, breaks_and_expected_subtype, closed, name):
         breaks, expected_subtype = breaks_and_expected_subtype
 
@@ -404,7 +404,7 @@ def test_constructor_string(self):
         # the interval of strings is already forbidden.
         pass
 
-    @pytest.mark.parameterize(
+    @pytest.mark.parametrize(
         "klass",
         [IntervalIndex, partial(Index, dtype="interval")],
         ids=["IntervalIndex", "Index"],
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index 1da6da15b9255..49b17f8b3d40e 100644
--- a/pandas/tests/indexes/interval/test_interval_tree.py
+++ b/pandas/tests/indexes/interval/test_interval_tree.py
@@ -98,7 +98,7 @@ def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype
         expected_missing = np.array([0], dtype="intp")
         tm.assert_numpy_array_equal(result_missing, expected_missing)
 
-    @pytest.mark.parameterize("dtype", ["int64", "float64", "uint64"])
+    @pytest.mark.parametrize("dtype", ["int64", "float64", "uint64"])
     def test_duplicates(self, dtype):
         left = np.array([0, 0, 0], dtype=dtype)
         tree = IntervalTree(left, left + 1)
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 81e14bcf16e22..486d0a51a0866 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -22,7 +22,7 @@ def mixed_index(self, dtype):
     def float_index(self, dtype):
         return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
 
-    @pytest.mark.parameterize(
+    @pytest.mark.parametrize(
         "index",
         [
             [1.5, 2, 3, 4, 5],
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index 8933fe7fcd7f8..b4a8c713d99ab 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -279,7 +279,7 @@ def test_orc_roundtrip_bytesio():
     tm.assert_equal(expected, got)
 
 
-@pytest.mark.parameterize(
+@pytest.mark.parametrize(
     "orc_writer_dtypes_not_supported",
     [
         np.array([1, 20], dtype="uint64"),
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 35df1586adb4a..1d108f610877e 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -3368,7 +3368,7 @@ def test_invalid_origin(self, unit):
         with pytest.raises(ValueError, match=msg):
             to_datetime("2005-01-01", origin="1960-01-01", unit=unit)
 
-    @pytest.mark.parameterize(
+    @pytest.mark.parametrize(
         "epochs",
         [
             Timestamp(1960, 1, 1),
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index a60e4107ec64c..51acd2f094684 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -245,8 +245,7 @@ def test_sub(date, offset_box, offset2):
         [BusinessHour, BusinessHour(), Timestamp(2014, 7, 1, 10, 00)],
     ],
 )
-def test_Mult1(offset_box, offset1):
-    dt = Timestamp(2008, 1, 2)
+def test_Mult1(offset_box, offset1, dt):
     assert dt + 10 * offset1 == dt + offset_box(10)
     assert dt + 5 * offset1 == dt + offset_box(5)
 

From c2075b810f79caa4286a108f01321c513f929ebd Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Mon, 25 Dec 2023 17:34:51 -0800
Subject: [PATCH 07/12] Fix more typos

---
 pandas/tests/frame/methods/test_join.py        | 4 ++--
 pandas/tests/frame/methods/test_nlargest.py    | 2 +-
 pandas/tests/frame/test_subclass.py            | 2 +-
 pandas/tests/groupby/test_index_as_string.py   | 2 +-
 pandas/tests/indexes/datetimelike_/test_nat.py | 2 +-
 pandas/tests/indexes/numeric/test_indexing.py  | 2 +-
 pandas/tests/indexes/numeric/test_numeric.py   | 3 ++-
 pandas/tests/io/json/test_normalize.py         | 2 +-
 pandas/tests/test_downstream.py                | 5 ++++-
 9 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 06c0f6ea3c5c0..6d181bb13786a 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -93,7 +93,7 @@ def right_w_dups(right_no_dup):
         ),
     ],
 )
-def test_join(left, right, how, sort, expected):
+def test_join(how, sort, expected):
     left = DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
     right = DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
     result = left.join(right, how=how, sort=sort, validate="1:1")
@@ -330,7 +330,7 @@ def test_join_overlap(float_frame):
     tm.assert_frame_equal(joined, expected.loc[:, joined.columns])
 
 
-def test_join_period_index(frame_with_period_index):
+def test_join_period_index():
     frame_with_period_index = DataFrame(
         data=np.arange(20).reshape(4, 5),
         columns=list("abcde"),
diff --git a/pandas/tests/frame/methods/test_nlargest.py b/pandas/tests/frame/methods/test_nlargest.py
index 22227bbb62d39..8a7b985c98069 100644
--- a/pandas/tests/frame/methods/test_nlargest.py
+++ b/pandas/tests/frame/methods/test_nlargest.py
@@ -62,7 +62,7 @@ class TestNLargestNSmallest:
         ],
     )
     @pytest.mark.parametrize("n", range(1, 11))
-    def test_nlargest_n(self, df_strings, nselect_method, n, order):
+    def test_nlargest_n(self, nselect_method, n, order):
         # GH#10393
         df = pd.DataFrame(
             {
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index cf4f2071a8aae..91f5de8e7d7f3 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -700,7 +700,7 @@ def test_idxmax_preserves_subclass(self):
         result = df.idxmax()
         assert isinstance(result, tm.SubclassedSeries)
 
-    def test_convert_dtypes_preserves_subclass(self, gpd_style_subclass_df):
+    def test_convert_dtypes_preserves_subclass(self):
         # GH 43668
         df = tm.SubclassedDataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
         result = df.convert_dtypes()
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 6d0e07b19b665..743db7e70b14b 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -49,7 +49,7 @@ def test_grouper_index_level_as_string(levels, key_strs, groupers):
         ["B", "outer", "inner"],
     ],
 )
-def test_grouper_index_level_as_string_series(series, levels):
+def test_grouper_index_level_as_string_series(levels):
     # Compute expected result
     df = pd.DataFrame(
         {
diff --git a/pandas/tests/indexes/datetimelike_/test_nat.py b/pandas/tests/indexes/datetimelike_/test_nat.py
index 1a667536b9266..3dd0ce1cbd637 100644
--- a/pandas/tests/indexes/datetimelike_/test_nat.py
+++ b/pandas/tests/indexes/datetimelike_/test_nat.py
@@ -19,7 +19,7 @@
         DatetimeIndex(["2011-01-01", "2011-01-02"], tz="UTC"),
     ],
 )
-def test_nat(self, index_without_na):
+def test_nat(index_without_na):
     empty_index = index_without_na[:0]
 
     index_with_na = index_without_na.copy(deep=True)
diff --git a/pandas/tests/indexes/numeric/test_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py
index 619b207d402fc..f2458a6c6114d 100644
--- a/pandas/tests/indexes/numeric/test_indexing.py
+++ b/pandas/tests/indexes/numeric/test_indexing.py
@@ -296,7 +296,7 @@ def test_get_indexer_int64(self):
         expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
         tm.assert_numpy_array_equal(indexer, expected)
 
-    def test_get_indexer_uint64(self, index_large):
+    def test_get_indexer_uint64(self):
         index_large = Index(
             [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
             dtype=np.uint64,
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 486d0a51a0866..3b47446d6da7f 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -32,7 +32,8 @@ def float_index(self, dtype):
         ],
         ids=["mixed", "float", "mixed_dec", "float_dec"],
     )
-    def test_repr_roundtrip(self, index):
+    def test_repr_roundtrip(self, index_data, dtype):
+        index = Index(index_data, dtype=dtype)
         tm.assert_index_equal(eval(repr(index)), index, exact=True)
 
     def check_coerce(self, a, b, is_float_index=True):
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index 4ef288d5fae27..7914d40ea8aaa 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -396,7 +396,7 @@ def test_non_ascii_key(self):
         result = json_normalize(json.loads(testjson))
         tm.assert_frame_equal(result, expected)
 
-    def test_missing_field(self, author_missing_data):
+    def test_missing_field(self):
         # GH20030:
         author_missing_data = [
             {"info": None},
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index c0bc82195990a..10776fe5d050f 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -2,6 +2,7 @@
 Testing that we work in the downstream packages
 """
 import array
+from functools import partial
 import subprocess
 import sys
 
@@ -261,7 +262,9 @@ def __radd__(self, other):
 
 
 @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
-@pytest.mark.parametrize("box", [memoryview, array.array, "dask", "xarray"])
+@pytest.mark.parametrize(
+    "box", [memoryview, partial(array.array, "i"), "dask", "xarray"]
+)
 def test_from_obscure_array(dtype, box):
     # GH#24539 recognize e.g xarray, dask, ...
     # Note: we dont do this for PeriodArray bc _from_sequence won't accept

From d1d999d5238897371ab38256d050eb04814012de Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Mon, 25 Dec 2023 17:46:19 -0800
Subject: [PATCH 08/12] fix typo

---
 pandas/tests/indexes/numeric/test_numeric.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 3b47446d6da7f..3ae746ac87179 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -23,7 +23,7 @@ def float_index(self, dtype):
         return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
 
     @pytest.mark.parametrize(
-        "index",
+        "index_data",
         [
             [1.5, 2, 3, 4, 5],
             [0.0, 2.5, 5.0, 7.5, 10.0],

From 587907d5ab187a3d3661afddc703e19eb2e28db5 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Mon, 25 Dec 2023 18:51:50 -0800
Subject: [PATCH 09/12] pylint

---
 pandas/tests/groupby/test_indexing.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/tests/groupby/test_indexing.py b/pandas/tests/groupby/test_indexing.py
index 4974e13a1b6ea..f839bf156ca00 100644
--- a/pandas/tests/groupby/test_indexing.py
+++ b/pandas/tests/groupby/test_indexing.py
@@ -150,7 +150,7 @@ def _make_df_from_data(data):
     df = _make_df_from_data(multiindex_data)
     result = df.groupby("Date", as_index=False).nth(slice(3, -3))
 
-    sliced = {date: multiindex_data[date][3:-3] for date in multiindex_data}
+    sliced = {date: values[3:-3] for date, values in multiindex_data.items()}
     expected = _make_df_from_data(sliced)
 
     tm.assert_frame_equal(result, expected)

From 6b2bca6b14b8233886190386d9a94fa24b30e245 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Thu, 28 Dec 2023 11:35:12 -0800
Subject: [PATCH 10/12] Uncomment

---
 pandas/tests/groupby/test_all_methods.py | 69 ++++++++++++------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/pandas/tests/groupby/test_all_methods.py b/pandas/tests/groupby/test_all_methods.py
index 9560310489a54..ad35bec70f668 100644
--- a/pandas/tests/groupby/test_all_methods.py
+++ b/pandas/tests/groupby/test_all_methods.py
@@ -18,44 +18,45 @@
 import pandas._testing as tm
 from pandas.tests.groupby import get_groupby_method_args
 
-# def test_multiindex_group_all_columns_when_empty(groupby_func):
-#     # GH 32464
-#     df = DataFrame({"a": [], "b": [], "c": []}).set_index(["a", "b", "c"])
-#     gb = df.groupby(["a", "b", "c"], group_keys=False)
-#     method = getattr(gb, groupby_func)
-#     args = get_groupby_method_args(groupby_func, df)
 
-#     warn = FutureWarning if groupby_func == "fillna" else None
-#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
-#     with tm.assert_produces_warning(warn, match=warn_msg):
-#         result = method(*args).index
-#     expected = df.index
-#     tm.assert_index_equal(result, expected)
+def test_multiindex_group_all_columns_when_empty(groupby_func):
+    # GH 32464
+    df = DataFrame({"a": [], "b": [], "c": []}).set_index(["a", "b", "c"])
+    gb = df.groupby(["a", "b", "c"], group_keys=False)
+    method = getattr(gb, groupby_func)
+    args = get_groupby_method_args(groupby_func, df)
+
+    warn = FutureWarning if groupby_func == "fillna" else None
+    warn_msg = "DataFrameGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=warn_msg):
+        result = method(*args).index
+    expected = df.index
+    tm.assert_index_equal(result, expected)
 
 
-# def test_duplicate_columns(request, groupby_func, as_index):
-#     # GH#50806
-#     if groupby_func == "corrwith":
-#         msg = "GH#50845 - corrwith fails when there are duplicate columns"
-#         request.applymarker(pytest.mark.xfail(reason=msg))
-#     df = DataFrame([[1, 3, 6], [1, 4, 7], [2, 5, 8]], columns=list("abb"))
-#     args = get_groupby_method_args(groupby_func, df)
-#     gb = df.groupby("a", as_index=as_index)
-#     warn = FutureWarning if groupby_func == "fillna" else None
-#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
-#     with tm.assert_produces_warning(warn, match=warn_msg):
-#         result = getattr(gb, groupby_func)(*args)
+def test_duplicate_columns(request, groupby_func, as_index):
+    # GH#50806
+    if groupby_func == "corrwith":
+        msg = "GH#50845 - corrwith fails when there are duplicate columns"
+        request.applymarker(pytest.mark.xfail(reason=msg))
+    df = DataFrame([[1, 3, 6], [1, 4, 7], [2, 5, 8]], columns=list("abb"))
+    args = get_groupby_method_args(groupby_func, df)
+    gb = df.groupby("a", as_index=as_index)
+    warn = FutureWarning if groupby_func == "fillna" else None
+    warn_msg = "DataFrameGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=warn_msg):
+        result = getattr(gb, groupby_func)(*args)
 
-#     expected_df = df.set_axis(["a", "b", "c"], axis=1)
-#     expected_args = get_groupby_method_args(groupby_func, expected_df)
-#     expected_gb = expected_df.groupby("a", as_index=as_index)
-#     warn = FutureWarning if groupby_func == "fillna" else None
-#     warn_msg = "DataFrameGroupBy.fillna is deprecated"
-#     with tm.assert_produces_warning(warn, match=warn_msg):
-#         expected = getattr(expected_gb, groupby_func)(*expected_args)
-#     if groupby_func not in ("size", "ngroup", "cumcount"):
-#         expected = expected.rename(columns={"c": "b"})
-#     tm.assert_equal(result, expected)
+    expected_df = df.set_axis(["a", "b", "c"], axis=1)
+    expected_args = get_groupby_method_args(groupby_func, expected_df)
+    expected_gb = expected_df.groupby("a", as_index=as_index)
+    warn = FutureWarning if groupby_func == "fillna" else None
+    warn_msg = "DataFrameGroupBy.fillna is deprecated"
+    with tm.assert_produces_warning(warn, match=warn_msg):
+        expected = getattr(expected_gb, groupby_func)(*expected_args)
+    if groupby_func not in ("size", "ngroup", "cumcount"):
+        expected = expected.rename(columns={"c": "b"})
+    tm.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize(

From 5c1d5d7c40c37b9b3b57765e065f32d2e3af9069 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Tue, 2 Jan 2024 14:37:09 -0800
Subject: [PATCH 11/12] add back parametrization

---
 pandas/tests/indexes/interval/test_interval.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index bce917b2fed62..7391d39bdde7b 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -860,6 +860,7 @@ def test_nbytes(self):
         expected = 64  # 4 * 8 * 2
         assert result == expected
 
+    @pytest.mark.parametrize("name", [None, "foo"])
     def test_set_closed(self, name, closed, other_closed):
         # GH 21670
         index = interval_range(0, 5, closed=closed, name=name)

From a3a9a9fd6990c7d6583ff4e769394bce7649e4c1 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Tue, 2 Jan 2024 15:49:16 -0800
Subject: [PATCH 12/12] Simplify

---
 pandas/tests/tseries/offsets/test_common.py | 25 +++++++++------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index 51acd2f094684..3792878973c15 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -229,23 +229,20 @@ def test_sub(date, offset_box, offset2):
 
 
 @pytest.mark.parametrize(
-    "offset_box, offset1, dt",
+    "offset_box, offset1",
     [
-        [BDay, BDay(), Timestamp(2008, 1, 1)],
-        [LastWeekOfMonth, LastWeekOfMonth(), Timestamp(2008, 1, 2)],
-        [WeekOfMonth, WeekOfMonth(), Timestamp(2008, 1, 2)],
-        [Week, Week(), Timestamp(2008, 1, 2)],
-        [SemiMonthBegin, SemiMonthBegin(), Timestamp(2008, 1, 2)],
-        [SemiMonthEnd, SemiMonthEnd(), Timestamp(2008, 1, 2)],
-        [
-            CustomBusinessHour,
-            CustomBusinessHour(weekmask="Tue Wed Thu Fri"),
-            Timestamp(2014, 7, 1, 10, 00),
-        ],
-        [BusinessHour, BusinessHour(), Timestamp(2014, 7, 1, 10, 00)],
+        [BDay, BDay()],
+        [LastWeekOfMonth, LastWeekOfMonth()],
+        [WeekOfMonth, WeekOfMonth()],
+        [Week, Week()],
+        [SemiMonthBegin, SemiMonthBegin()],
+        [SemiMonthEnd, SemiMonthEnd()],
+        [CustomBusinessHour, CustomBusinessHour(weekmask="Tue Wed Thu Fri")],
+        [BusinessHour, BusinessHour()],
     ],
 )
-def test_Mult1(offset_box, offset1, dt):
+def test_Mult1(offset_box, offset1):
+    dt = Timestamp(2008, 1, 2)
     assert dt + 10 * offset1 == dt + offset_box(10)
     assert dt + 5 * offset1 == dt + offset_box(5)