From 7e461a18d9f6928132afec6f48ce968b3e989ba6 Mon Sep 17 00:00:00 2001
From: Kaiqi Dong <kaiqi@kth.se>
Date: Mon, 3 Dec 2018 17:43:52 +0100
Subject: [PATCH 1/6] remove \n from docstring

---
 pandas/core/arrays/datetimes.py  | 26 +++++++++++++-------------
 pandas/core/arrays/timedeltas.py | 16 ++++++++--------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index cfe3afcf3730a..b3df505d56d78 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -82,7 +82,7 @@ def f(self):
         return result
 
     f.__name__ = name
-    f.__doc__ = docstring
+    f.__doc__ = "\n{}\n".format(docstring)
     return property(f)
 
 
@@ -1072,19 +1072,19 @@ def date(self):
 
         return tslib.ints_to_pydatetime(timestamps, box="date")
 
-    year = _field_accessor('year', 'Y', "\n The year of the datetime\n")
+    year = _field_accessor('year', 'Y', "The year of the datetime")
     month = _field_accessor('month', 'M',
-                            "\n The month as January=1, December=12 \n")
-    day = _field_accessor('day', 'D', "\nThe days of the datetime\n")
-    hour = _field_accessor('hour', 'h', "\nThe hours of the datetime\n")
-    minute = _field_accessor('minute', 'm', "\nThe minutes of the datetime\n")
-    second = _field_accessor('second', 's', "\nThe seconds of the datetime\n")
+                            "The month as January=1, December=12")
+    day = _field_accessor('day', 'D', "The days of the datetime")
+    hour = _field_accessor('hour', 'h', "The hours of the datetime")
+    minute = _field_accessor('minute', 'm', "The minutes of the datetime")
+    second = _field_accessor('second', 's', "The seconds of the datetime")
     microsecond = _field_accessor('microsecond', 'us',
-                                  "\nThe microseconds of the datetime\n")
+                                  "The microseconds of the datetime")
     nanosecond = _field_accessor('nanosecond', 'ns',
-                                 "\nThe nanoseconds of the datetime\n")
+                                 "The nanoseconds of the datetime")
     weekofyear = _field_accessor('weekofyear', 'woy',
-                                 "\nThe week ordinal of the year\n")
+                                 "The week ordinal of the year")
     week = weekofyear
     _dayofweek_doc = """
     The day of the week with Monday=0, Sunday=6.
@@ -1129,12 +1129,12 @@ def date(self):
         "The name of day in a week (ex: Friday)\n\n.. deprecated:: 0.23.0")
 
     dayofyear = _field_accessor('dayofyear', 'doy',
-                                "\nThe ordinal day of the year\n")
-    quarter = _field_accessor('quarter', 'q', "\nThe quarter of the date\n")
+                                "The ordinal day of the year")
+    quarter = _field_accessor('quarter', 'q', "The quarter of the date")
     days_in_month = _field_accessor(
         'days_in_month',
         'dim',
-        "\nThe number of days in the month\n")
+        "The number of days in the month")
     daysinmonth = days_in_month
     _is_month_doc = """
         Indicates whether the date is the {first_or_last} day of the month.
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 830283d31a929..4afc9f5483c2a 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -59,7 +59,7 @@ def f(self):
         return result
 
     f.__name__ = name
-    f.__doc__ = docstring
+    f.__doc__ = "\n{}\n".format(docstring)
     return property(f)
 
 
@@ -684,16 +684,16 @@ def to_pytimedelta(self):
         return tslibs.ints_to_pytimedelta(self.asi8)
 
     days = _field_accessor("days", "days",
-                           "\nNumber of days for each element.\n")
+                           "Number of days for each element.")
     seconds = _field_accessor("seconds", "seconds",
-                              "\nNumber of seconds (>= 0 and less than 1 day) "
-                              "for each element.\n")
+                              "Number of seconds (>= 0 and less than 1 day) "
+                              "for each element.")
     microseconds = _field_accessor("microseconds", "microseconds",
-                                   "\nNumber of microseconds (>= 0 and less "
-                                   "than 1 second) for each element.\n")
+                                   "Number of microseconds (>= 0 and less "
+                                   "than 1 second) for each element.")
     nanoseconds = _field_accessor("nanoseconds", "nanoseconds",
-                                  "\nNumber of nanoseconds (>= 0 and less "
-                                  "than 1 microsecond) for each element.\n")
+                                  "Number of nanoseconds (>= 0 and less "
+                                  "than 1 microsecond) for each element.")
 
     @property
     def components(self):

From dea38f24c0067ae3fe9484b837c9649714213bba Mon Sep 17 00:00:00 2001
From: Kaiqi <kaiqi@kth.se>
Date: Tue, 14 Jan 2020 21:26:31 +0100
Subject: [PATCH 2/6] fix issue 17038

---
 pandas/core/reshape/pivot.py       |  4 +++-
 pandas/tests/reshape/test_pivot.py | 20 ++++++++++++++------
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index b443ba142369c..9743d90f4dd04 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -117,7 +117,9 @@ def pivot_table(
                 agged[v] = maybe_downcast_to_dtype(agged[v], data[v].dtype)
 
     table = agged
-    if table.index.nlevels > 1:
+
+    # GH 17038, this check should only happen if index is specified
+    if table.index.nlevels > 1 and index:
         # Related GH #17123
         # If index_names are integers, determine whether the integers refer
         # to the level position or name.
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 743fc50c87e96..46a05123c9fdd 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -896,12 +896,6 @@ def _check_output(
             totals = table.loc[("All", ""), value_col]
             assert totals == self.data[value_col].mean()
 
-        # no rows
-        rtable = self.data.pivot_table(
-            columns=["AA", "BB"], margins=True, aggfunc=np.mean
-        )
-        assert isinstance(rtable, Series)
-
         table = self.data.pivot_table(index=["AA", "BB"], margins=True, aggfunc="mean")
         for item in ["DD", "EE", "FF"]:
             totals = table.loc[("All", ""), item]
@@ -972,6 +966,20 @@ def test_pivot_integer_columns(self):
 
         tm.assert_frame_equal(table, table2, check_names=False)
 
+    @pytest.mark.parametrize("cols", [(1, 2), ("a", "b"), (1, "b"), ("a", 1)])
+    def test_pivot_table_multiindex_only(self, cols):
+        # GH 17038
+        df2 = DataFrame({cols[0]: [1, 2, 3], cols[1]: [1, 2, 3], "v": [4, 5, 6]})
+
+        result = df2.pivot_table(values="v", columns=cols)
+        expected = DataFrame(
+            [[4, 5, 6]],
+            columns=MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)], names=cols),
+            index=Index(["v"]),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
     def test_pivot_no_level_overlap(self):
         # GH #1181
 

From cd9e7ac3f31ffaf95cd628863df911dea9fa1248 Mon Sep 17 00:00:00 2001
From: Kaiqi <kaiqi@kth.se>
Date: Tue, 14 Jan 2020 21:29:43 +0100
Subject: [PATCH 3/6] revert change

---
 pandas/core/reshape/pivot.py       |  3 +--
 pandas/tests/reshape/test_pivot.py | 20 ++++++--------------
 2 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index 9743d90f4dd04..a7cdbb0da7a4e 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -118,8 +118,7 @@ def pivot_table(
 
     table = agged
 
-    # GH 17038, this check should only happen if index is specified
-    if table.index.nlevels > 1 and index:
+    if table.index.nlevels > 1:
         # Related GH #17123
         # If index_names are integers, determine whether the integers refer
         # to the level position or name.
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 46a05123c9fdd..743fc50c87e96 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -896,6 +896,12 @@ def _check_output(
             totals = table.loc[("All", ""), value_col]
             assert totals == self.data[value_col].mean()
 
+        # no rows
+        rtable = self.data.pivot_table(
+            columns=["AA", "BB"], margins=True, aggfunc=np.mean
+        )
+        assert isinstance(rtable, Series)
+
         table = self.data.pivot_table(index=["AA", "BB"], margins=True, aggfunc="mean")
         for item in ["DD", "EE", "FF"]:
             totals = table.loc[("All", ""), item]
@@ -966,20 +972,6 @@ def test_pivot_integer_columns(self):
 
         tm.assert_frame_equal(table, table2, check_names=False)
 
-    @pytest.mark.parametrize("cols", [(1, 2), ("a", "b"), (1, "b"), ("a", 1)])
-    def test_pivot_table_multiindex_only(self, cols):
-        # GH 17038
-        df2 = DataFrame({cols[0]: [1, 2, 3], cols[1]: [1, 2, 3], "v": [4, 5, 6]})
-
-        result = df2.pivot_table(values="v", columns=cols)
-        expected = DataFrame(
-            [[4, 5, 6]],
-            columns=MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)], names=cols),
-            index=Index(["v"]),
-        )
-
-        tm.assert_frame_equal(result, expected)
-
     def test_pivot_no_level_overlap(self):
         # GH #1181
 

From e5e912be0f596943067a7df812442764d311a086 Mon Sep 17 00:00:00 2001
From: Kaiqi <kaiqi@kth.se>
Date: Tue, 14 Jan 2020 21:30:16 +0100
Subject: [PATCH 4/6] revert change

---
 pandas/core/reshape/pivot.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index a7cdbb0da7a4e..b443ba142369c 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -117,7 +117,6 @@ def pivot_table(
                 agged[v] = maybe_downcast_to_dtype(agged[v], data[v].dtype)
 
     table = agged
-
     if table.index.nlevels > 1:
         # Related GH #17123
         # If index_names are integers, determine whether the integers refer

From 29ae7ec1c3ba2bf45d1a852bd6aa4639be29e0b3 Mon Sep 17 00:00:00 2001
From: Kaiqi <kaiqi@kth.se>
Date: Sun, 26 Apr 2020 22:25:30 +0200
Subject: [PATCH 5/6] Clean and break up consistency tests

---
 pandas/tests/window/common.py                 | 171 ++++++++++--------
 .../tests/window/moments/test_moments_ewm.py  |  86 ++++++++-
 .../window/moments/test_moments_expanding.py  |  55 ++++--
 .../window/moments/test_moments_rolling.py    | 154 +++++++++++-----
 4 files changed, 322 insertions(+), 144 deletions(-)

diff --git a/pandas/tests/window/common.py b/pandas/tests/window/common.py
index 6aeada3152dbb..d7c8b413f948d 100644
--- a/pandas/tests/window/common.py
+++ b/pandas/tests/window/common.py
@@ -252,43 +252,25 @@ def _test_moments_consistency_var_debiasing_factors(
                 var_debiasing_factors_x = var_debiasing_factors(x)
                 tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
 
-    def _test_moments_consistency(
-        self,
-        min_periods,
-        count,
-        mean,
-        corr,
-        var_unbiased=None,
-        std_unbiased=None,
-        cov_unbiased=None,
-        var_biased=None,
-        std_biased=None,
-        cov_biased=None,
-    ):
+    def _check_pairwise_moment(self, dispatch, name, **kwargs):
+        def get_result(obj, obj2=None):
+            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
 
+        result = get_result(self.frame)
+        result = result.loc[(slice(None), 1), 5]
+        result.index = result.index.droplevel(1)
+        expected = get_result(self.frame[1], self.frame[5])
+        tm.assert_series_equal(result, expected, check_names=False)
+
+    def _test_moments_consistency_var_data(
+        self, min_periods, count, mean, var_unbiased, var_biased
+    ):
         for (x, is_constant, no_nans) in self.data:
             count_x = count(x)
             mean_x = mean(x)
-
-            for (std, var, cov) in [
-                (std_biased, var_biased, cov_biased),
-                (std_unbiased, var_unbiased, cov_unbiased),
-            ]:
-
-                # check that var(x), std(x), and cov(x) are all >= 0
+            for var in [var_biased, var_unbiased]:
                 var_x = var(x)
-                std_x = std(x)
                 assert not (var_x < 0).any().any()
-                assert not (std_x < 0).any().any()
-                if cov:
-                    cov_x_x = cov(x, x)
-                    assert not (cov_x_x < 0).any().any()
-
-                    # check that var(x) == cov(x, x)
-                    tm.assert_equal(var_x, cov_x_x)
-
-                # check that var(x) == std(x)^2
-                tm.assert_equal(var_x, std_x * std_x)
 
                 if var is var_biased:
                     # check that biased var(x) == mean(x^2) - mean(x)^2
@@ -304,55 +286,88 @@ def _test_moments_consistency(
                         expected[count_x < 2] = np.nan
                     tm.assert_equal(var_x, expected)
 
-                if isinstance(x, Series):
-                    for (y, is_constant, no_nans) in self.data:
-                        if not x.isna().equals(y.isna()):
-                            # can only easily test two Series with similar
-                            # structure
-                            continue
-
-                        # check that cor(x, y) is symmetric
-                        corr_x_y = corr(x, y)
-                        corr_y_x = corr(y, x)
-                        tm.assert_equal(corr_x_y, corr_y_x)
-
-                        if cov:
-                            # check that cov(x, y) is symmetric
-                            cov_x_y = cov(x, y)
-                            cov_y_x = cov(y, x)
-                            tm.assert_equal(cov_x_y, cov_y_x)
-
-                            # check that cov(x, y) == (var(x+y) - var(x) -
-                            # var(y)) / 2
-                            var_x_plus_y = var(x + y)
-                            var_y = var(y)
-                            tm.assert_equal(
-                                cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y)
-                            )
-
-                            # check that corr(x, y) == cov(x, y) / (std(x) *
-                            # std(y))
-                            std_y = std(y)
-                            tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
-
-                            if cov is cov_biased:
-                                # check that biased cov(x, y) == mean(x*y) -
-                                # mean(x)*mean(y)
-                                mean_y = mean(y)
-                                mean_x_times_y = mean(x * y)
-                                tm.assert_equal(
-                                    cov_x_y, mean_x_times_y - (mean_x * mean_y)
-                                )
+    def _test_moments_consistency_std_data(
+        self, std_unbiased, var_unbiased, std_biased, var_biased
+    ):
+        for (x, is_constant, no_nans) in self.data:
+            for (std, var) in [(std_biased, var_biased), (std_unbiased, var_unbiased)]:
+                var_x = var(x)
+                std_x = std(x)
+                assert not (var_x < 0).any().any()
+                assert not (std_x < 0).any().any()
 
-    def _check_pairwise_moment(self, dispatch, name, **kwargs):
-        def get_result(obj, obj2=None):
-            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
+                # check that var(x) == std(x)^2
+                tm.assert_equal(var_x, std_x * std_x)
 
-        result = get_result(self.frame)
-        result = result.loc[(slice(None), 1), 5]
-        result.index = result.index.droplevel(1)
-        expected = get_result(self.frame[1], self.frame[5])
-        tm.assert_series_equal(result, expected, check_names=False)
+    def _test_moments_consistency_cov_data(
+        self, cov_unbiased, var_unbiased, cov_biased, var_biased
+    ):
+        for (x, is_constant, no_nans) in self.data:
+            for (cov, var) in [(cov_biased, var_biased), (cov_unbiased, var_unbiased)]:
+                var_x = var(x)
+                assert not (var_x < 0).any().any()
+                if cov:
+                    cov_x_x = cov(x, x)
+                    assert not (cov_x_x < 0).any().any()
+
+                    # check that var(x) == cov(x, x)
+                    tm.assert_equal(var_x, cov_x_x)
+
+    def _test_moments_consistency_series_data(
+        self,
+        corr,
+        mean,
+        std_biased,
+        std_unbiased,
+        cov_unbiased,
+        var_unbiased,
+        var_biased,
+        cov_biased,
+    ):
+        for (x, is_constant, no_nans) in self.data:
+            if isinstance(x, Series):
+                y = x
+                mean_x = mean(x)
+                if not x.isna().equals(y.isna()):
+                    # can only easily test two Series with similar
+                    # structure
+                    pass
+
+                # check that cor(x, y) is symmetric
+                corr_x_y = corr(x, y)
+                corr_y_x = corr(y, x)
+                tm.assert_equal(corr_x_y, corr_y_x)
+
+                for (std, var, cov) in [
+                    (std_biased, var_biased, cov_biased),
+                    (std_unbiased, var_unbiased, cov_unbiased),
+                ]:
+                    var_x = var(x)
+                    std_x = std(x)
+
+                    if cov:
+                        # check that cov(x, y) is symmetric
+                        cov_x_y = cov(x, y)
+                        cov_y_x = cov(y, x)
+                        tm.assert_equal(cov_x_y, cov_y_x)
+
+                        # check that cov(x, y) == (var(x+y) - var(x) -
+                        # var(y)) / 2
+                        var_x_plus_y = var(x + y)
+                        var_y = var(y)
+                        tm.assert_equal(cov_x_y, 0.5 * (var_x_plus_y - var_x - var_y))
+
+                        # check that corr(x, y) == cov(x, y) / (std(x) *
+                        # std(y))
+                        std_y = std(y)
+                        tm.assert_equal(corr_x_y, cov_x_y / (std_x * std_y))
+
+                        if cov is cov_biased:
+                            # check that biased cov(x, y) == mean(x*y) -
+                            # mean(x)*mean(y)
+                            mean_y = mean(y)
+                            mean_x_times_y = mean(x * y)
+                            tm.assert_equal(cov_x_y, mean_x_times_y - (mean_x * mean_y))
 
 
 def ew_func(A, B, com, name, **kwargs):
diff --git a/pandas/tests/window/moments/test_moments_ewm.py b/pandas/tests/window/moments/test_moments_ewm.py
index 599761259e041..78b086927adfb 100644
--- a/pandas/tests/window/moments/test_moments_ewm.py
+++ b/pandas/tests/window/moments/test_moments_ewm.py
@@ -398,10 +398,90 @@ def _ewma(s, com, min_periods, adjust, ignore_na):
                 )
             ),
         )
-        # test consistency between different ewm* moments
-        self._test_moments_consistency(
-            min_periods=min_periods,
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewm_consistency_var(self, min_periods, adjust, ignore_na):
+        com = 3.0
+        self._test_moments_consistency_var_data(
+            min_periods,
             count=lambda x: x.expanding().count(),
+            mean=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).mean(),
+            var_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=False)
+            ),
+            var_biased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=True)
+            ),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewm_consistency_std(self, min_periods, adjust, ignore_na):
+        com = 3.0
+        self._test_moments_consistency_std_data(
+            var_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=False)
+            ),
+            std_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).std(bias=False)
+            ),
+            var_biased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=True)
+            ),
+            std_biased=lambda x: x.ewm(
+                com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+            ).std(bias=True),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewm_consistency_cov(self, min_periods, adjust, ignore_na):
+        com = 3.0
+        self._test_moments_consistency_cov_data(
+            var_unbiased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=False)
+            ),
+            cov_unbiased=lambda x, y: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).cov(y, bias=False)
+            ),
+            var_biased=lambda x: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).var(bias=True)
+            ),
+            cov_biased=lambda x, y: (
+                x.ewm(
+                    com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
+                ).cov(y, bias=True)
+            ),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    @pytest.mark.parametrize("adjust", [True, False])
+    @pytest.mark.parametrize("ignore_na", [True, False])
+    def test_ewm_consistency_series_data(self, min_periods, adjust, ignore_na):
+        com = 3.0
+        self._test_moments_consistency_series_data(
             mean=lambda x: x.ewm(
                 com=com, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na
             ).mean(),
diff --git a/pandas/tests/window/moments/test_moments_expanding.py b/pandas/tests/window/moments/test_moments_expanding.py
index 9dfaecee9caeb..01940d83a4fa9 100644
--- a/pandas/tests/window/moments/test_moments_expanding.py
+++ b/pandas/tests/window/moments/test_moments_expanding.py
@@ -367,20 +367,6 @@ def test_expanding_consistency(self, min_periods):
                     / (x.expanding().count() - 1.0).replace(0.0, np.nan)
                 ),
             )
-            self._test_moments_consistency(
-                min_periods=min_periods,
-                count=lambda x: x.expanding(min_periods=min_periods).count(),
-                mean=lambda x: x.expanding(min_periods=min_periods).mean(),
-                corr=lambda x, y: x.expanding(min_periods=min_periods).corr(y),
-                var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
-                std_unbiased=lambda x: x.expanding(min_periods=min_periods).std(),
-                cov_unbiased=lambda x, y: x.expanding(min_periods=min_periods).cov(y),
-                var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
-                std_biased=lambda x: x.expanding(min_periods=min_periods).std(ddof=0),
-                cov_biased=lambda x, y: x.expanding(min_periods=min_periods).cov(
-                    y, ddof=0
-                ),
-            )
 
             # test consistency between expanding_xyz() and either (a)
             # expanding_apply of Series.xyz(), or (b) expanding_apply of
@@ -418,3 +404,44 @@ def test_expanding_consistency(self, min_periods):
                     # GH 9422
                     if name in ["sum", "prod"]:
                         tm.assert_equal(expanding_f_result, expanding_apply_f_result)
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    def test_moments_consistency_var(self, min_periods):
+        self._test_moments_consistency_var_data(
+            min_periods=min_periods,
+            count=lambda x: x.expanding(min_periods=min_periods).count(),
+            mean=lambda x: x.expanding(min_periods=min_periods).mean(),
+            var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+            var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    def test_expanding_consistency_std(self, min_periods):
+        self._test_moments_consistency_std_data(
+            var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+            std_unbiased=lambda x: x.expanding(min_periods=min_periods).std(),
+            var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+            std_biased=lambda x: x.expanding(min_periods=min_periods).std(ddof=0),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    def test_expanding_consistency_cov(self, min_periods):
+        self._test_moments_consistency_cov_data(
+            var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+            cov_unbiased=lambda x, y: x.expanding(min_periods=min_periods).cov(y),
+            var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+            cov_biased=lambda x, y: x.expanding(min_periods=min_periods).cov(y, ddof=0),
+        )
+
+    @pytest.mark.parametrize("min_periods", [0, 1, 2, 3, 4])
+    def test_expanding_consistency_series(self, min_periods):
+        self._test_moments_consistency_series_data(
+            mean=lambda x: x.expanding(min_periods=min_periods).mean(),
+            corr=lambda x, y: x.expanding(min_periods=min_periods).corr(y),
+            var_unbiased=lambda x: x.expanding(min_periods=min_periods).var(),
+            std_unbiased=lambda x: x.expanding(min_periods=min_periods).std(),
+            cov_unbiased=lambda x, y: x.expanding(min_periods=min_periods).cov(y),
+            var_biased=lambda x: x.expanding(min_periods=min_periods).var(ddof=0),
+            std_biased=lambda x: x.expanding(min_periods=min_periods).std(ddof=0),
+            cov_biased=lambda x, y: x.expanding(min_periods=min_periods).cov(y, ddof=0),
+        )
diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py
index 3c5352fcd997d..33e870df4d8b2 100644
--- a/pandas/tests/window/moments/test_moments_rolling.py
+++ b/pandas/tests/window/moments/test_moments_rolling.py
@@ -1013,55 +1013,6 @@ def test_rolling_consistency(self, window, min_periods, center):
                 ),
             )
 
-            self._test_moments_consistency(
-                min_periods=min_periods,
-                count=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).count()
-                ),
-                mean=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).mean()
-                ),
-                corr=lambda x, y: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).corr(y)
-                ),
-                var_unbiased=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).var()
-                ),
-                std_unbiased=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).std()
-                ),
-                cov_unbiased=lambda x, y: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).cov(y)
-                ),
-                var_biased=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).var(ddof=0)
-                ),
-                std_biased=lambda x: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).std(ddof=0)
-                ),
-                cov_biased=lambda x, y: (
-                    x.rolling(
-                        window=window, min_periods=min_periods, center=center
-                    ).cov(y, ddof=0)
-                ),
-            )
-
             # test consistency between rolling_xyz() and either (a)
             # rolling_apply of Series.xyz(), or (b) rolling_apply of
             # np.nanxyz()
@@ -1104,6 +1055,111 @@ def test_rolling_consistency(self, window, min_periods, center):
                     if name in ["sum", "prod"]:
                         tm.assert_equal(rolling_f_result, rolling_apply_f_result)
 
+    @pytest.mark.parametrize(
+        "window,min_periods,center", list(_rolling_consistency_cases())
+    )
+    def test_rolling_consistency_var(self, window, min_periods, center):
+        self._test_moments_consistency_var_data(
+            min_periods,
+            count=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).count()
+            ),
+            mean=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).mean()
+            ),
+            var_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var()
+            ),
+            var_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var(
+                    ddof=0
+                )
+            ),
+        )
+
+    @pytest.mark.parametrize(
+        "window,min_periods,center", list(_rolling_consistency_cases())
+    )
+    def test_rolling_consistency_std(self, window, min_periods, center):
+        self._test_moments_consistency_std_data(
+            var_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var()
+            ),
+            std_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).std()
+            ),
+            var_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var(
+                    ddof=0
+                )
+            ),
+            std_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).std(
+                    ddof=0
+                )
+            ),
+        )
+
+    @pytest.mark.parametrize(
+        "window,min_periods,center", list(_rolling_consistency_cases())
+    )
+    def test_rolling_consistency_cov(self, window, min_periods, center):
+        self._test_moments_consistency_cov_data(
+            var_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var()
+            ),
+            cov_unbiased=lambda x, y: (
+                x.rolling(window=window, min_periods=min_periods, center=center).cov(y)
+            ),
+            var_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var(
+                    ddof=0
+                )
+            ),
+            cov_biased=lambda x, y: (
+                x.rolling(window=window, min_periods=min_periods, center=center).cov(
+                    y, ddof=0
+                )
+            ),
+        )
+
+    @pytest.mark.parametrize(
+        "window,min_periods,center", list(_rolling_consistency_cases())
+    )
+    def test_rolling_consistency_series(self, window, min_periods, center):
+        self._test_moments_consistency_series_data(
+            mean=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).mean()
+            ),
+            corr=lambda x, y: (
+                x.rolling(window=window, min_periods=min_periods, center=center).corr(y)
+            ),
+            var_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var()
+            ),
+            std_unbiased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).std()
+            ),
+            cov_unbiased=lambda x, y: (
+                x.rolling(window=window, min_periods=min_periods, center=center).cov(y)
+            ),
+            var_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).var(
+                    ddof=0
+                )
+            ),
+            std_biased=lambda x: (
+                x.rolling(window=window, min_periods=min_periods, center=center).std(
+                    ddof=0
+                )
+            ),
+            cov_biased=lambda x, y: (
+                x.rolling(window=window, min_periods=min_periods, center=center).cov(
+                    y, ddof=0
+                )
+            ),
+        )
+
     # binary moments
     def test_rolling_cov(self):
         A = self.series

From 89bd7b1aa383282e6a23fc97f775491f0a01462b Mon Sep 17 00:00:00 2001
From: Kaiqi <kaiqi@kth.se>
Date: Sun, 26 Apr 2020 22:30:03 +0200
Subject: [PATCH 6/6] reorder

---
 pandas/tests/window/common.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/pandas/tests/window/common.py b/pandas/tests/window/common.py
index d7c8b413f948d..d1d0fb519aa31 100644
--- a/pandas/tests/window/common.py
+++ b/pandas/tests/window/common.py
@@ -252,16 +252,6 @@ def _test_moments_consistency_var_debiasing_factors(
                 var_debiasing_factors_x = var_debiasing_factors(x)
                 tm.assert_equal(var_unbiased_x, var_biased_x * var_debiasing_factors_x)
 
-    def _check_pairwise_moment(self, dispatch, name, **kwargs):
-        def get_result(obj, obj2=None):
-            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
-
-        result = get_result(self.frame)
-        result = result.loc[(slice(None), 1), 5]
-        result.index = result.index.droplevel(1)
-        expected = get_result(self.frame[1], self.frame[5])
-        tm.assert_series_equal(result, expected, check_names=False)
-
     def _test_moments_consistency_var_data(
         self, min_periods, count, mean, var_unbiased, var_biased
     ):
@@ -369,6 +359,16 @@ def _test_moments_consistency_series_data(
                             mean_x_times_y = mean(x * y)
                             tm.assert_equal(cov_x_y, mean_x_times_y - (mean_x * mean_y))
 
+    def _check_pairwise_moment(self, dispatch, name, **kwargs):
+        def get_result(obj, obj2=None):
+            return getattr(getattr(obj, dispatch)(**kwargs), name)(obj2)
+
+        result = get_result(self.frame)
+        result = result.loc[(slice(None), 1), 5]
+        result.index = result.index.droplevel(1)
+        expected = get_result(self.frame[1], self.frame[5])
+        tm.assert_series_equal(result, expected, check_names=False)
+
 
 def ew_func(A, B, com, name, **kwargs):
     return getattr(A.ewm(com, **kwargs), name)(B)