Tst verify return none in tests/frame (pandas-dev#35232)

Author: r-toroxel

pandas/tests/frame/indexing/test_categorical.py

@@ -326,7 +326,10 @@ def test_assigning_ops(self):
         df = DataFrame({"cats": catsf, "values": valuesf}, index=idxf)
 
         exp_fancy = exp_multi_row.copy()
-        exp_fancy["cats"].cat.set_categories(["a", "b", "c"], inplace=True)
+        return_value = exp_fancy["cats"].cat.set_categories(
+            ["a", "b", "c"], inplace=True
+        )
+        assert return_value is None
 
         df[df["cats"] == "c"] = ["b", 2]
         # category c is kept in .categories

pandas/tests/frame/indexing/test_mask.py

@@ -36,12 +36,14 @@ def test_mask_inplace(self):
 
         rdf = df.copy()
 
-        rdf.where(cond, inplace=True)
+        return_value = rdf.where(cond, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(rdf, df.where(cond))
         tm.assert_frame_equal(rdf, df.mask(~cond))
 
         rdf = df.copy()
-        rdf.where(cond, -df, inplace=True)
+        return_value = rdf.where(cond, -df, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(rdf, df.where(cond, -df))
         tm.assert_frame_equal(rdf, df.mask(~cond, -df))
 

pandas/tests/frame/indexing/test_where.py

@@ -162,7 +162,8 @@ def _check_set(df, cond, check_dtypes=True):
             econd = cond.reindex_like(df).fillna(True)
             expected = dfi.mask(~econd)
 
-            dfi.where(cond, np.nan, inplace=True)
+            return_value = dfi.where(cond, np.nan, inplace=True)
+            assert return_value is None
             tm.assert_frame_equal(dfi, expected)
 
             # dtypes (and confirm upcasts)x
@@ -303,7 +304,8 @@ def test_where_bug(self):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(result > 2, np.nan, inplace=True)
+        return_value = result.where(result > 2, np.nan, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     def test_where_bug_mixed(self, sint_dtype):
@@ -324,7 +326,8 @@ def test_where_bug_mixed(self, sint_dtype):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(result > 2, np.nan, inplace=True)
+        return_value = result.where(result > 2, np.nan, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     def test_where_bug_transposition(self):
@@ -417,7 +420,8 @@ def create():
         result = df.where(pd.notna(df), df.mean(), axis="columns")
         tm.assert_frame_equal(result, expected)
 
-        df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
+        return_value = df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
+        assert return_value is None
         tm.assert_frame_equal(df, expected)
 
         df = create().fillna(0)
@@ -453,15 +457,17 @@ def test_where_axis(self):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(mask, s, axis="index", inplace=True)
+        return_value = result.where(mask, s, axis="index", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame([[0, 1], [0, 1]], dtype="float64")
         result = df.where(mask, s, axis="columns")
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(mask, s, axis="columns", inplace=True)
+        return_value = result.where(mask, s, axis="columns", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         # Upcast needed
@@ -474,7 +480,8 @@ def test_where_axis(self):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(mask, s, axis="index", inplace=True)
+        return_value = result.where(mask, s, axis="index", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame([[0, np.nan], [0, np.nan]])
@@ -488,7 +495,8 @@ def test_where_axis(self):
             }
         )
         result = df.copy()
-        result.where(mask, s, axis="columns", inplace=True)
+        return_value = result.where(mask, s, axis="columns", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         # Multiple dtypes (=> multiple Blocks)
@@ -511,7 +519,8 @@ def test_where_axis(self):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(mask, s1, axis="columns", inplace=True)
+        return_value = result.where(mask, s1, axis="columns", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         result = df.where(mask, s2, axis="index")
@@ -521,7 +530,8 @@ def test_where_axis(self):
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result.where(mask, s2, axis="index", inplace=True)
+        return_value = result.where(mask, s2, axis="index", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         # DataFrame vs DataFrame
@@ -534,10 +544,12 @@ def test_where_axis(self):
         result = df.where(mask, d1, axis="index")
         tm.assert_frame_equal(result, expected)
         result = df.copy()
-        result.where(mask, d1, inplace=True)
+        return_value = result.where(mask, d1, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
         result = df.copy()
-        result.where(mask, d1, inplace=True, axis="index")
+        return_value = result.where(mask, d1, inplace=True, axis="index")
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         d2 = df.copy().drop(1, axis=1)
@@ -549,10 +561,12 @@ def test_where_axis(self):
         result = df.where(mask, d2, axis="columns")
         tm.assert_frame_equal(result, expected)
         result = df.copy()
-        result.where(mask, d2, inplace=True)
+        return_value = result.where(mask, d2, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
         result = df.copy()
-        result.where(mask, d2, inplace=True, axis="columns")
+        return_value = result.where(mask, d2, inplace=True, axis="columns")
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     def test_where_callable(self):

pandas/tests/frame/methods/test_clip.py

@@ -22,7 +22,8 @@ def test_inplace_clip(self, float_frame):
         median = float_frame.median().median()
         frame_copy = float_frame.copy()
 
-        frame_copy.clip(upper=median, lower=median, inplace=True)
+        return_value = frame_copy.clip(upper=median, lower=median, inplace=True)
+        assert return_value is None
         assert not (frame_copy.values != median).any()
 
     def test_dataframe_clip(self):

pandas/tests/frame/methods/test_drop.py

@@ -70,8 +70,10 @@ def test_drop_names(self):
         df_dropped_b = df.drop("b")
         df_dropped_e = df.drop("e", axis=1)
         df_inplace_b, df_inplace_e = df.copy(), df.copy()
-        df_inplace_b.drop("b", inplace=True)
-        df_inplace_e.drop("e", axis=1, inplace=True)
+        return_value = df_inplace_b.drop("b", inplace=True)
+        assert return_value is None
+        return_value = df_inplace_e.drop("e", axis=1, inplace=True)
+        assert return_value is None
         for obj in (df_dropped_b, df_dropped_e, df_inplace_b, df_inplace_e):
             assert obj.index.name == "first"
             assert obj.columns.name == "second"
@@ -148,7 +150,8 @@ def test_drop(self):
         # GH#5628
         df = pd.DataFrame(np.random.randn(10, 3), columns=list("abc"))
         expected = df[~(df.b > 0)]
-        df.drop(labels=df[df.b > 0].index, inplace=True)
+        return_value = df.drop(labels=df[df.b > 0].index, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(df, expected)
 
     def test_drop_multiindex_not_lexsorted(self):

pandas/tests/frame/methods/test_interpolate.py

@@ -246,11 +246,13 @@ def test_interp_inplace(self):
         df = DataFrame({"a": [1.0, 2.0, np.nan, 4.0]})
         expected = DataFrame({"a": [1.0, 2.0, 3.0, 4.0]})
         result = df.copy()
-        result["a"].interpolate(inplace=True)
+        return_value = result["a"].interpolate(inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         result = df.copy()
-        result["a"].interpolate(inplace=True, downcast="infer")
+        return_value = result["a"].interpolate(inplace=True, downcast="infer")
+        assert return_value is None
         tm.assert_frame_equal(result, expected.astype("int64"))
 
     def test_interp_inplace_row(self):
@@ -259,7 +261,8 @@ def test_interp_inplace_row(self):
             {"a": [1.0, 2.0, 3.0, 4.0], "b": [np.nan, 2.0, 3.0, 4.0], "c": [3, 2, 2, 2]}
         )
         expected = result.interpolate(method="linear", axis=1, inplace=False)
-        result.interpolate(method="linear", axis=1, inplace=True)
+        return_value = result.interpolate(method="linear", axis=1, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     def test_interp_ignore_all_good(self):
@@ -297,7 +300,8 @@ def test_interp_time_inplace_axis(self, axis):
         expected = DataFrame(index=idx, columns=idx, data=data)
 
         result = expected.interpolate(axis=0, method="time")
-        expected.interpolate(axis=0, method="time", inplace=True)
+        return_value = expected.interpolate(axis=0, method="time", inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("axis_name, axis_number", [("index", 0), ("columns", 1)])

pandas/tests/frame/methods/test_rename.py

@@ -150,7 +150,8 @@ def test_rename_inplace(self, float_frame):
 
         c_id = id(float_frame["C"])
         float_frame = float_frame.copy()
-        float_frame.rename(columns={"C": "foo"}, inplace=True)
+        return_value = float_frame.rename(columns={"C": "foo"}, inplace=True)
+        assert return_value is None
 
         assert "C" not in float_frame
         assert "foo" in float_frame

pandas/tests/frame/methods/test_rename_axis.py

@@ -10,14 +10,16 @@ def test_rename_axis_inplace(self, float_frame):
         # GH#15704
         expected = float_frame.rename_axis("foo")
         result = float_frame.copy()
-        no_return = result.rename_axis("foo", inplace=True)
+        return_value = no_return = result.rename_axis("foo", inplace=True)
+        assert return_value is None
 
         assert no_return is None
         tm.assert_frame_equal(result, expected)
 
         expected = float_frame.rename_axis("bar", axis=1)
         result = float_frame.copy()
-        no_return = result.rename_axis("bar", axis=1, inplace=True)
+        return_value = no_return = result.rename_axis("bar", axis=1, inplace=True)
+        assert return_value is None
 
         assert no_return is None
         tm.assert_frame_equal(result, expected)