diff --git a/pandas/conftest.py b/pandas/conftest.py
index c325a268fe418..4a3fb5c2916c6 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1838,16 +1838,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/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index ebcd7cbd963d7..121bfb78fe5c8 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
@@ -1499,6 +1480,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 3ec6d70494902..e2ef83c243957 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -1977,9 +1977,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 e3a467e8bf65b..1b83c048411a8 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1662,25 +1662,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
@@ -1702,7 +1683,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()
 
@@ -1711,6 +1692,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()
@@ -1752,9 +1738,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()
 
@@ -1764,6 +1748,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 02f0b9e20871d..82802dd6e99eb 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(
@@ -112,7 +93,9 @@ 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")
     tm.assert_frame_equal(result, expected)
 
@@ -347,7 +330,12 @@ 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"),
+        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..8a7b985c98069 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(
@@ -81,9 +62,15 @@ 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 = 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..91f5de8e7d7f3 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
@@ -710,14 +700,21 @@ 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()
         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 f27e99809176c..e73fb15a54181 100644
--- a/pandas/tests/groupby/methods/test_describe.py
+++ b/pandas/tests/groupby/methods/test_describe.py
@@ -226,49 +226,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 5c9f7febe32b3..35f2f47f5ff97 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -419,14 +419,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",
     [
@@ -444,10 +436,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
     )
@@ -467,19 +463,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",
     [
@@ -495,7 +478,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(
@@ -507,6 +490,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()
@@ -517,17 +508,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",
     [
@@ -556,11 +536,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_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 4aaf3de9a23b2..743db7e70b14b 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)
@@ -71,8 +49,17 @@ def test_grouper_index_level_as_string(frame, 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(
+        {
+            "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..f839bf156ca00 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,28 +145,12 @@ 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))
 
-    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)
@@ -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..3dd0ce1cbd637 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.parametrize(
+    "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(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..e9864723f026e 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.parametrize(
+        "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.parametrize("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.parametrize(
+        "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.py b/pandas/tests/indexes/interval/test_interval.py
index 89b991318be0d..7391d39bdde7b 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"])
     def test_set_closed(self, name, closed, other_closed):
         # GH 21670
         index = interval_range(0, 5, closed=closed, name=name)
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index 45b25f2533afd..49b17f8b3d40e 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.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_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py
index cd28d519313ed..f2458a6c6114d 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])
@@ -303,7 +296,11 @@ 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,
+        )
         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 dc5a6719284a6..4416034795463 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.parametrize(
+        "index_data",
+        [
             [1.5, 2, 3, 4, 5],
             [0.0, 2.5, 5.0, 7.5, 10.0],
             [5, 4, 3, 2, 1.5],
@@ -28,18 +32,8 @@ 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):
+    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):
@@ -227,8 +221,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/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/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/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 13d786f98c42b..e0898a636474c 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -38,13 +38,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 ada6f88679673..c455b0bc8599b 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -68,116 +68,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
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 8bc6b48922a4f..6d8cc501ade6c 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/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..7914d40ea8aaa 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 = [
@@ -424,8 +396,15 @@ 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},
+            {
+                "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 9fa46222bce1a..7254fd7cb345d 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/io/test_orc.py b/pandas/tests/io/test_orc.py
index a4021311fc963..b4a8c713d99ab 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.parametrize(
+    "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/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index e6488bcc4568f..21a38c43f4294 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)
@@ -571,6 +520,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(
@@ -589,6 +562,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(
@@ -2134,16 +2128,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",
@@ -2192,7 +2176,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 33502f576dd2f..00df8064d5190 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -604,486 +604,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"]})
@@ -2620,11 +2140,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):
@@ -2657,9 +2413,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,
@@ -2668,7 +2422,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 6564ac0fd7e8a..af156a1da87f2 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -30,12 +30,6 @@
 from pandas.core.reshape.pivot import pivot_table
 
 
-@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):
@@ -303,8 +297,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/test_downstream.py b/pandas/tests/test_downstream.py
index 51ce73ef54300..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
 
@@ -9,7 +10,6 @@
 import pytest
 
 from pandas.errors import IntCastingNaNError
-import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
@@ -261,46 +261,25 @@ 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, 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
     #  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]
 
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 5b856bc632a1d..cb94427ae8961 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -3300,37 +3300,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
@@ -3388,7 +3357,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.parametrize(
+        "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]
         )
@@ -3405,7 +3385,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",
@@ -3414,7 +3394,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 aa4e22f71ad66..3792878973c15 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
 
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",
     [