diff --git a/pandas/tests/window/conftest.py b/pandas/tests/window/conftest.py
index 3b4ed4859b1cc..e5c5579d35a5c 100644
--- a/pandas/tests/window/conftest.py
+++ b/pandas/tests/window/conftest.py
@@ -344,3 +344,36 @@ def halflife_with_times(request):
 def dtypes(request):
     """Dtypes for window tests"""
     return request.param
+
+
+@pytest.fixture(
+    params=[
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", "C"]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1.0, 0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0.0, 1]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", 1]),
+        DataFrame([[2.0, 4.0], [1.0, 2.0], [5.0, 2.0], [8.0, 1.0]], columns=[1, 0.0]),
+        DataFrame([[2, 4.0], [1, 2.0], [5, 2.0], [8, 1.0]], columns=[0, 1.0]),
+        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1.0]], columns=[1.0, "X"]),
+    ]
+)
+def pairwise_frames(request):
+    """Pairwise frames test_pairwise"""
+    return request.param
+
+
+@pytest.fixture
+def pairwise_target_frame():
+    """Pairwise target frame for test_pairwise"""
+    return DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0, 1])
+
+
+@pytest.fixture
+def pairwise_other_frame():
+    """Pairwise other frame for test_pairwise"""
+    return DataFrame(
+        [[None, 1, 1], [None, 1, 2], [None, 3, 2], [None, 8, 1]],
+        columns=["Y", "Z", "X"],
+    )
diff --git a/pandas/tests/window/test_apply.py b/pandas/tests/window/test_apply.py
index bc38634da8941..b7343d835fa6e 100644
--- a/pandas/tests/window/test_apply.py
+++ b/pandas/tests/window/test_apply.py
@@ -155,8 +155,6 @@ def foo(x, par):
     result = df.rolling(1).apply(foo, args=args_kwargs[0], kwargs=args_kwargs[1])
     tm.assert_frame_equal(result, expected)
 
-    result = df.rolling(1).apply(foo, args=(10,))
-
     midx = MultiIndex.from_tuples([(1, 0), (1, 1)], names=["gr", None])
     expected = Series([11.0, 12.0], index=midx, name="a")
 
diff --git a/pandas/tests/window/test_base_indexer.py b/pandas/tests/window/test_base_indexer.py
index ab73e075eed04..f681b19d57600 100644
--- a/pandas/tests/window/test_base_indexer.py
+++ b/pandas/tests/window/test_base_indexer.py
@@ -148,12 +148,12 @@ def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs)
     match = "Forward-looking windows can't have center=True"
     with pytest.raises(ValueError, match=match):
         rolling = constructor(values).rolling(window=indexer, center=True)
-        result = getattr(rolling, func)()
+        getattr(rolling, func)()
 
     match = "Forward-looking windows don't support setting the closed argument"
     with pytest.raises(ValueError, match=match):
         rolling = constructor(values).rolling(window=indexer, closed="right")
-        result = getattr(rolling, func)()
+        getattr(rolling, func)()
 
     rolling = constructor(values).rolling(window=indexer, min_periods=2)
     result = getattr(rolling, func)()
diff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py
index 146eca07c523e..e5006fd391f90 100644
--- a/pandas/tests/window/test_expanding.py
+++ b/pandas/tests/window/test_expanding.py
@@ -29,15 +29,22 @@ def test_constructor(which):
     c(min_periods=1, center=True)
     c(min_periods=1, center=False)
 
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+@pytest.mark.filterwarnings(
+    "ignore:The `center` argument on `expanding` will be removed in the future"
+)
+def test_constructor_invalid(which, w):
     # not valid
-    for w in [2.0, "foo", np.array([2])]:
-        msg = "min_periods must be an integer"
-        with pytest.raises(ValueError, match=msg):
-            c(min_periods=w)
-
-        msg = "center must be a boolean"
-        with pytest.raises(ValueError, match=msg):
-            c(min_periods=1, center=w)
+
+    c = which.expanding
+    msg = "min_periods must be an integer"
+    with pytest.raises(ValueError, match=msg):
+        c(min_periods=w)
+
+    msg = "center must be a boolean"
+    with pytest.raises(ValueError, match=msg):
+        c(min_periods=1, center=w)
 
 
 @pytest.mark.parametrize("method", ["std", "mean", "sum", "max", "min", "var"])
diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index 786cf68d28871..0eebd657e97b7 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -8,7 +8,7 @@
 
 
 class TestGrouperGrouping:
-    def setup_method(self, method):
+    def setup_method(self):
         self.series = Series(np.arange(10))
         self.frame = DataFrame({"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)})
 
@@ -55,19 +55,25 @@ def test_getitem_multiple(self):
         result = r.B.count()
         tm.assert_series_equal(result, expected)
 
-    def test_rolling(self):
+    @pytest.mark.parametrize(
+        "f", ["sum", "mean", "min", "max", "count", "kurt", "skew"]
+    )
+    def test_rolling(self, f):
         g = self.frame.groupby("A")
         r = g.rolling(window=4)
 
-        for f in ["sum", "mean", "min", "max", "count", "kurt", "skew"]:
-            result = getattr(r, f)()
-            expected = g.apply(lambda x: getattr(x.rolling(4), f)())
-            tm.assert_frame_equal(result, expected)
+        result = getattr(r, f)()
+        expected = g.apply(lambda x: getattr(x.rolling(4), f)())
+        tm.assert_frame_equal(result, expected)
 
-        for f in ["std", "var"]:
-            result = getattr(r, f)(ddof=1)
-            expected = g.apply(lambda x: getattr(x.rolling(4), f)(ddof=1))
-            tm.assert_frame_equal(result, expected)
+    @pytest.mark.parametrize("f", ["std", "var"])
+    def test_rolling_ddof(self, f):
+        g = self.frame.groupby("A")
+        r = g.rolling(window=4)
+
+        result = getattr(r, f)(ddof=1)
+        expected = g.apply(lambda x: getattr(x.rolling(4), f)(ddof=1))
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
@@ -81,26 +87,26 @@ def test_rolling_quantile(self, interpolation):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_rolling_corr_cov(self):
+    @pytest.mark.parametrize("f", ["corr", "cov"])
+    def test_rolling_corr_cov(self, f):
         g = self.frame.groupby("A")
         r = g.rolling(window=4)
 
-        for f in ["corr", "cov"]:
-            result = getattr(r, f)(self.frame)
+        result = getattr(r, f)(self.frame)
 
-            def func(x):
-                return getattr(x.rolling(4), f)(self.frame)
+        def func(x):
+            return getattr(x.rolling(4), f)(self.frame)
 
-            expected = g.apply(func)
-            tm.assert_frame_equal(result, expected)
+        expected = g.apply(func)
+        tm.assert_frame_equal(result, expected)
 
-            result = getattr(r.B, f)(pairwise=True)
+        result = getattr(r.B, f)(pairwise=True)
 
-            def func(x):
-                return getattr(x.B.rolling(4), f)(pairwise=True)
+        def func(x):
+            return getattr(x.B.rolling(4), f)(pairwise=True)
 
-            expected = g.apply(func)
-            tm.assert_series_equal(result, expected)
+        expected = g.apply(func)
+        tm.assert_series_equal(result, expected)
 
     def test_rolling_apply(self, raw):
         g = self.frame.groupby("A")
@@ -134,20 +140,25 @@ def test_rolling_apply_mutability(self):
         result = g.rolling(window=2).sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_expanding(self):
+    @pytest.mark.parametrize(
+        "f", ["sum", "mean", "min", "max", "count", "kurt", "skew"]
+    )
+    def test_expanding(self, f):
         g = self.frame.groupby("A")
         r = g.expanding()
 
-        for f in ["sum", "mean", "min", "max", "count", "kurt", "skew"]:
+        result = getattr(r, f)()
+        expected = g.apply(lambda x: getattr(x.expanding(), f)())
+        tm.assert_frame_equal(result, expected)
 
-            result = getattr(r, f)()
-            expected = g.apply(lambda x: getattr(x.expanding(), f)())
-            tm.assert_frame_equal(result, expected)
+    @pytest.mark.parametrize("f", ["std", "var"])
+    def test_expanding_ddof(self, f):
+        g = self.frame.groupby("A")
+        r = g.expanding()
 
-        for f in ["std", "var"]:
-            result = getattr(r, f)(ddof=0)
-            expected = g.apply(lambda x: getattr(x.expanding(), f)(ddof=0))
-            tm.assert_frame_equal(result, expected)
+        result = getattr(r, f)(ddof=0)
+        expected = g.apply(lambda x: getattr(x.expanding(), f)(ddof=0))
+        tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
         "interpolation", ["linear", "lower", "higher", "midpoint", "nearest"]
@@ -161,26 +172,26 @@ def test_expanding_quantile(self, interpolation):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_expanding_corr_cov(self):
+    @pytest.mark.parametrize("f", ["corr", "cov"])
+    def test_expanding_corr_cov(self, f):
         g = self.frame.groupby("A")
         r = g.expanding()
 
-        for f in ["corr", "cov"]:
-            result = getattr(r, f)(self.frame)
+        result = getattr(r, f)(self.frame)
 
-            def func(x):
-                return getattr(x.expanding(), f)(self.frame)
+        def func(x):
+            return getattr(x.expanding(), f)(self.frame)
 
-            expected = g.apply(func)
-            tm.assert_frame_equal(result, expected)
+        expected = g.apply(func)
+        tm.assert_frame_equal(result, expected)
 
-            result = getattr(r.B, f)(pairwise=True)
+        result = getattr(r.B, f)(pairwise=True)
 
-            def func(x):
-                return getattr(x.B.expanding(), f)(pairwise=True)
+        def func(x):
+            return getattr(x.B.expanding(), f)(pairwise=True)
 
-            expected = g.apply(func)
-            tm.assert_series_equal(result, expected)
+        expected = g.apply(func)
+        tm.assert_series_equal(result, expected)
 
     def test_expanding_apply(self, raw):
         g = self.frame.groupby("A")
diff --git a/pandas/tests/window/test_pairwise.py b/pandas/tests/window/test_pairwise.py
index 7f4e85b385b2d..b39d052a702c0 100644
--- a/pandas/tests/window/test_pairwise.py
+++ b/pandas/tests/window/test_pairwise.py
@@ -11,26 +11,15 @@
 class TestPairwise:
 
     # GH 7738
-    df1s = [
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0, 1]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1, 1]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", "C"]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[1.0, 0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=[0.0, 1]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1]], columns=["C", 1]),
-        DataFrame([[2.0, 4.0], [1.0, 2.0], [5.0, 2.0], [8.0, 1.0]], columns=[1, 0.0]),
-        DataFrame([[2, 4.0], [1, 2.0], [5, 2.0], [8, 1.0]], columns=[0, 1.0]),
-        DataFrame([[2, 4], [1, 2], [5, 2], [8, 1.0]], columns=[1.0, "X"]),
-    ]
-    df2 = DataFrame(
-        [[None, 1, 1], [None, 1, 2], [None, 3, 2], [None, 8, 1]],
-        columns=["Y", "Z", "X"],
-    )
-    s = Series([1, 1, 3, 8])
+    @pytest.mark.parametrize("f", [lambda x: x.cov(), lambda x: x.corr()])
+    def test_no_flex(self, pairwise_frames, pairwise_target_frame, f):
 
-    def compare(self, result, expected):
+        # DataFrame methods (which do not call flex_binary_moment())
 
+        result = f(pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.columns)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
         # since we have sorted the results
         # we can only compare non-nans
         result = result.dropna().values
@@ -38,19 +27,6 @@ def compare(self, result, expected):
 
         tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
-    @pytest.mark.parametrize("f", [lambda x: x.cov(), lambda x: x.corr()])
-    def test_no_flex(self, f):
-
-        # DataFrame methods (which do not call flex_binary_moment())
-
-        results = [f(df) for df in self.df1s]
-        for (df, result) in zip(self.df1s, results):
-            tm.assert_index_equal(result.index, df.columns)
-            tm.assert_index_equal(result.columns, df.columns)
-        for i, result in enumerate(results):
-            if i > 0:
-                self.compare(result, results[0])
-
     @pytest.mark.parametrize(
         "f",
         [
@@ -62,24 +38,27 @@ def test_no_flex(self, f):
             lambda x: x.ewm(com=3).corr(pairwise=True),
         ],
     )
-    def test_pairwise_with_self(self, f):
+    def test_pairwise_with_self(self, pairwise_frames, pairwise_target_frame, f):
 
         # DataFrame with itself, pairwise=True
         # note that we may construct the 1st level of the MI
         # in a non-monotonic way, so compare accordingly
-        results = []
-        for i, df in enumerate(self.df1s):
-            result = f(df)
-            tm.assert_index_equal(result.index.levels[0], df.index, check_names=False)
-            tm.assert_numpy_array_equal(
-                safe_sort(result.index.levels[1]), safe_sort(df.columns.unique())
-            )
-            tm.assert_index_equal(result.columns, df.columns)
-            results.append(df)
-
-        for i, result in enumerate(results):
-            if i > 0:
-                self.compare(result, results[0])
+        result = f(pairwise_frames)
+        tm.assert_index_equal(
+            result.index.levels[0], pairwise_frames.index, check_names=False
+        )
+        tm.assert_numpy_array_equal(
+            safe_sort(result.index.levels[1]),
+            safe_sort(pairwise_frames.columns.unique()),
+        )
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     @pytest.mark.parametrize(
         "f",
@@ -92,16 +71,19 @@ def test_pairwise_with_self(self, f):
             lambda x: x.ewm(com=3).corr(pairwise=False),
         ],
     )
-    def test_no_pairwise_with_self(self, f):
+    def test_no_pairwise_with_self(self, pairwise_frames, pairwise_target_frame, f):
 
         # DataFrame with itself, pairwise=False
-        results = [f(df) for df in self.df1s]
-        for (df, result) in zip(self.df1s, results):
-            tm.assert_index_equal(result.index, df.index)
-            tm.assert_index_equal(result.columns, df.columns)
-        for i, result in enumerate(results):
-            if i > 0:
-                self.compare(result, results[0])
+        result = f(pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     @pytest.mark.parametrize(
         "f",
@@ -114,18 +96,26 @@ def test_no_pairwise_with_self(self, f):
             lambda x, y: x.ewm(com=3).corr(y, pairwise=True),
         ],
     )
-    def test_pairwise_with_other(self, f):
+    def test_pairwise_with_other(
+        self, pairwise_frames, pairwise_target_frame, pairwise_other_frame, f
+    ):
 
         # DataFrame with another DataFrame, pairwise=True
-        results = [f(df, self.df2) for df in self.df1s]
-        for (df, result) in zip(self.df1s, results):
-            tm.assert_index_equal(result.index.levels[0], df.index, check_names=False)
-            tm.assert_numpy_array_equal(
-                safe_sort(result.index.levels[1]), safe_sort(self.df2.columns.unique())
-            )
-        for i, result in enumerate(results):
-            if i > 0:
-                self.compare(result, results[0])
+        result = f(pairwise_frames, pairwise_other_frame)
+        tm.assert_index_equal(
+            result.index.levels[0], pairwise_frames.index, check_names=False
+        )
+        tm.assert_numpy_array_equal(
+            safe_sort(result.index.levels[1]),
+            safe_sort(pairwise_other_frame.columns.unique()),
+        )
+        expected = f(pairwise_target_frame, pairwise_other_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     @pytest.mark.parametrize(
         "f",
@@ -138,26 +128,29 @@ def test_pairwise_with_other(self, f):
             lambda x, y: x.ewm(com=3).corr(y, pairwise=False),
         ],
     )
-    def test_no_pairwise_with_other(self, f):
+    def test_no_pairwise_with_other(self, pairwise_frames, pairwise_other_frame, f):
 
         # DataFrame with another DataFrame, pairwise=False
-        results = [
-            f(df, self.df2) if df.columns.is_unique else None for df in self.df1s
-        ]
-        for (df, result) in zip(self.df1s, results):
-            if result is not None:
-                with warnings.catch_warnings(record=True):
-                    warnings.simplefilter("ignore", RuntimeWarning)
-                    # we can have int and str columns
-                    expected_index = df.index.union(self.df2.index)
-                    expected_columns = df.columns.union(self.df2.columns)
-                tm.assert_index_equal(result.index, expected_index)
-                tm.assert_index_equal(result.columns, expected_columns)
-            else:
-                with pytest.raises(ValueError, match="'arg1' columns are not unique"):
-                    f(df, self.df2)
-                with pytest.raises(ValueError, match="'arg2' columns are not unique"):
-                    f(self.df2, df)
+        result = (
+            f(pairwise_frames, pairwise_other_frame)
+            if pairwise_frames.columns.is_unique
+            else None
+        )
+        if result is not None:
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("ignore", RuntimeWarning)
+                # we can have int and str columns
+                expected_index = pairwise_frames.index.union(pairwise_other_frame.index)
+                expected_columns = pairwise_frames.columns.union(
+                    pairwise_other_frame.columns
+                )
+            tm.assert_index_equal(result.index, expected_index)
+            tm.assert_index_equal(result.columns, expected_columns)
+        else:
+            with pytest.raises(ValueError, match="'arg1' columns are not unique"):
+                f(pairwise_frames, pairwise_other_frame)
+            with pytest.raises(ValueError, match="'arg2' columns are not unique"):
+                f(pairwise_other_frame, pairwise_frames)
 
     @pytest.mark.parametrize(
         "f",
@@ -170,18 +163,28 @@ def test_no_pairwise_with_other(self, f):
             lambda x, y: x.ewm(com=3).corr(y),
         ],
     )
-    def test_pairwise_with_series(self, f):
+    def test_pairwise_with_series(self, pairwise_frames, pairwise_target_frame, f):
 
         # DataFrame with a Series
-        results = [f(df, self.s) for df in self.df1s] + [
-            f(self.s, df) for df in self.df1s
-        ]
-        for (df, result) in zip(self.df1s, results):
-            tm.assert_index_equal(result.index, df.index)
-            tm.assert_index_equal(result.columns, df.columns)
-        for i, result in enumerate(results):
-            if i > 0:
-                self.compare(result, results[0])
+        result = f(pairwise_frames, Series([1, 1, 3, 8]))
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(pairwise_target_frame, Series([1, 1, 3, 8]))
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
+
+        result = f(Series([1, 1, 3, 8]), pairwise_frames)
+        tm.assert_index_equal(result.index, pairwise_frames.index)
+        tm.assert_index_equal(result.columns, pairwise_frames.columns)
+        expected = f(Series([1, 1, 3, 8]), pairwise_target_frame)
+        # since we have sorted the results
+        # we can only compare non-nans
+        result = result.dropna().values
+        expected = expected.dropna().values
+        tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     def test_corr_freq_memory_error(self):
         # GH 31789
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 4dfa0287bbb03..9ac4871ad24a1 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -39,22 +39,27 @@ def test_constructor(which):
     with pytest.raises(ValueError, match=msg):
         c(-1)
 
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+def test_invalid_constructor(which, w):
     # not valid
-    for w in [2.0, "foo", np.array([2])]:
-        msg = (
-            "window must be an integer|"
-            "passed window foo is not compatible with a datetimelike index"
-        )
-        with pytest.raises(ValueError, match=msg):
-            c(window=w)
-
-        msg = "min_periods must be an integer"
-        with pytest.raises(ValueError, match=msg):
-            c(window=2, min_periods=w)
-
-        msg = "center must be a boolean"
-        with pytest.raises(ValueError, match=msg):
-            c(window=2, min_periods=1, center=w)
+
+    c = which.rolling
+
+    msg = (
+        "window must be an integer|"
+        "passed window foo is not compatible with a datetimelike index"
+    )
+    with pytest.raises(ValueError, match=msg):
+        c(window=w)
+
+    msg = "min_periods must be an integer"
+    with pytest.raises(ValueError, match=msg):
+        c(window=2, min_periods=w)
+
+    msg = "center must be a boolean"
+    with pytest.raises(ValueError, match=msg):
+        c(window=2, min_periods=1, center=w)
 
 
 @td.skip_if_no_scipy
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index 8aa4d7103e48a..ea4d7df6700e9 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -50,41 +50,44 @@ def test_doc_string(self):
         df
         df.rolling("2s").sum()
 
-    def test_valid(self):
-
-        df = self.regular
+    def test_invalid_window_non_int(self):
 
         # not a valid freq
         msg = "passed window foobar is not compatible with a datetimelike index"
         with pytest.raises(ValueError, match=msg):
-            df.rolling(window="foobar")
+            self.regular.rolling(window="foobar")
         # not a datetimelike index
         msg = "window must be an integer"
         with pytest.raises(ValueError, match=msg):
-            df.reset_index().rolling(window="foobar")
+            self.regular.reset_index().rolling(window="foobar")
+
+    @pytest.mark.parametrize("freq", ["2MS", offsets.MonthBegin(2)])
+    def test_invalid_window_nonfixed(self, freq):
 
         # non-fixed freqs
         msg = "\\<2 \\* MonthBegins\\> is a non-fixed frequency"
-        for freq in ["2MS", offsets.MonthBegin(2)]:
-            with pytest.raises(ValueError, match=msg):
-                df.rolling(window=freq)
+        with pytest.raises(ValueError, match=msg):
+            self.regular.rolling(window=freq)
 
-        for freq in ["1D", offsets.Day(2), "2ms"]:
-            df.rolling(window=freq)
+    @pytest.mark.parametrize("freq", ["1D", offsets.Day(2), "2ms"])
+    def test_valid_window(self, freq):
+        self.regular.rolling(window=freq)
 
+    @pytest.mark.parametrize("minp", [1.0, "foo", np.array([1, 2, 3])])
+    def test_invalid_minp(self, minp):
         # non-integer min_periods
         msg = (
             r"local variable 'minp' referenced before assignment|"
             "min_periods must be an integer"
         )
-        for minp in [1.0, "foo", np.array([1, 2, 3])]:
-            with pytest.raises(ValueError, match=msg):
-                df.rolling(window="1D", min_periods=minp)
+        with pytest.raises(ValueError, match=msg):
+            self.regular.rolling(window="1D", min_periods=minp)
 
+    def test_invalid_center_datetimelike(self):
         # center is not implemented
         msg = "center is not implemented for datetimelike and offset based windows"
         with pytest.raises(NotImplementedError, match=msg):
-            df.rolling(window="1D", center=True)
+            self.regular.rolling(window="1D", center=True)
 
     def test_on(self):
 
@@ -585,14 +588,9 @@ def test_freqs_ops(self, freq, op, result_data):
 
         tm.assert_series_equal(result, expected)
 
-    def test_all(self):
-
-        # simple comparison of integer vs time-based windowing
-        df = self.regular * 2
-        er = df.rolling(window=1)
-        r = df.rolling(window="1s")
-
-        for f in [
+    @pytest.mark.parametrize(
+        "f",
+        [
             "sum",
             "mean",
             "count",
@@ -603,29 +601,26 @@ def test_all(self):
             "skew",
             "min",
             "max",
-        ]:
+        ],
+    )
+    def test_all(self, f):
+
+        # simple comparison of integer vs time-based windowing
+        df = self.regular * 2
+        er = df.rolling(window=1)
+        r = df.rolling(window="1s")
 
-            result = getattr(r, f)()
-            expected = getattr(er, f)()
-            tm.assert_frame_equal(result, expected)
+        result = getattr(r, f)()
+        expected = getattr(er, f)()
+        tm.assert_frame_equal(result, expected)
 
         result = r.quantile(0.5)
         expected = er.quantile(0.5)
         tm.assert_frame_equal(result, expected)
 
-    def test_all2(self):
-
-        # more sophisticated comparison of integer vs.
-        # time-based windowing
-        df = DataFrame(
-            {"B": np.arange(50)}, index=date_range("20130101", periods=50, freq="H")
-        )
-        # in-range data
-        dft = df.between_time("09:00", "16:00")
-
-        r = dft.rolling(window="5H")
-
-        for f in [
+    @pytest.mark.parametrize(
+        "f",
+        [
             "sum",
             "mean",
             "count",
@@ -636,25 +631,35 @@ def test_all2(self):
             "skew",
             "min",
             "max",
-        ]:
+        ],
+    )
+    def test_all2(self, f):
+
+        # more sophisticated comparison of integer vs.
+        # time-based windowing
+        df = DataFrame(
+            {"B": np.arange(50)}, index=date_range("20130101", periods=50, freq="H")
+        )
+        # in-range data
+        dft = df.between_time("09:00", "16:00")
+
+        r = dft.rolling(window="5H")
 
-            result = getattr(r, f)()
+        result = getattr(r, f)()
 
-            # we need to roll the days separately
-            # to compare with a time-based roll
-            # finally groupby-apply will return a multi-index
-            # so we need to drop the day
-            def agg_by_day(x):
-                x = x.between_time("09:00", "16:00")
-                return getattr(x.rolling(5, min_periods=1), f)()
+        # we need to roll the days separately
+        # to compare with a time-based roll
+        # finally groupby-apply will return a multi-index
+        # so we need to drop the day
+        def agg_by_day(x):
+            x = x.between_time("09:00", "16:00")
+            return getattr(x.rolling(5, min_periods=1), f)()
 
-            expected = (
-                df.groupby(df.index.day)
-                .apply(agg_by_day)
-                .reset_index(level=0, drop=True)
-            )
+        expected = (
+            df.groupby(df.index.day).apply(agg_by_day).reset_index(level=0, drop=True)
+        )
 
-            tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def test_groupby_monotonic(self):
 
diff --git a/pandas/tests/window/test_window.py b/pandas/tests/window/test_window.py
index a450d29797c41..a3fff3122f80a 100644
--- a/pandas/tests/window/test_window.py
+++ b/pandas/tests/window/test_window.py
@@ -19,16 +19,25 @@ def test_constructor(which):
     c(win_type="boxcar", window=2, min_periods=1, center=True)
     c(win_type="boxcar", window=2, min_periods=1, center=False)
 
+
+@pytest.mark.parametrize("w", [2.0, "foo", np.array([2])])
+@td.skip_if_no_scipy
+def test_invalid_constructor(which, w):
     # not valid
-    for w in [2.0, "foo", np.array([2])]:
-        with pytest.raises(ValueError, match="min_periods must be an integer"):
-            c(win_type="boxcar", window=2, min_periods=w)
-        with pytest.raises(ValueError, match="center must be a boolean"):
-            c(win_type="boxcar", window=2, min_periods=1, center=w)
-
-    for wt in ["foobar", 1]:
-        with pytest.raises(ValueError, match="Invalid win_type"):
-            c(win_type=wt, window=2)
+
+    c = which.rolling
+    with pytest.raises(ValueError, match="min_periods must be an integer"):
+        c(win_type="boxcar", window=2, min_periods=w)
+    with pytest.raises(ValueError, match="center must be a boolean"):
+        c(win_type="boxcar", window=2, min_periods=1, center=w)
+
+
+@pytest.mark.parametrize("wt", ["foobar", 1])
+@td.skip_if_no_scipy
+def test_invalid_constructor_wintype(which, wt):
+    c = which.rolling
+    with pytest.raises(ValueError, match="Invalid win_type"):
+        c(win_type=wt, window=2)
 
 
 @td.skip_if_no_scipy