diff --git a/pandas/tests/frame/indexing/test_categorical.py b/pandas/tests/frame/indexing/test_categorical.py
index d94dc8d2ffe00..cfc22b9b18729 100644
--- a/pandas/tests/frame/indexing/test_categorical.py
+++ b/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
diff --git a/pandas/tests/frame/indexing/test_mask.py b/pandas/tests/frame/indexing/test_mask.py
index 30db6110efc80..23f3a18881782 100644
--- a/pandas/tests/frame/indexing/test_mask.py
+++ b/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))
 
diff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py
index 24eb424bd5735..d114a3178b686 100644
--- a/pandas/tests/frame/indexing/test_where.py
+++ b/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,7 +457,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, 1], [0, 1]], dtype="float64")
@@ -461,7 +466,8 @@ def test_where_axis(self):
         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):
diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py
index 34727da3b95ae..ca62b56664518 100644
--- a/pandas/tests/frame/methods/test_clip.py
+++ b/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):
diff --git a/pandas/tests/frame/methods/test_drop.py b/pandas/tests/frame/methods/test_drop.py
index 177d10cdbf615..aa44a2427dc8f 100644
--- a/pandas/tests/frame/methods/test_drop.py
+++ b/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):
diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py
index facb116646573..ddb5723e7bd3e 100644
--- a/pandas/tests/frame/methods/test_interpolate.py
+++ b/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)])
diff --git a/pandas/tests/frame/methods/test_rename.py b/pandas/tests/frame/methods/test_rename.py
index ffad526d3f4d1..eb908e9472fe2 100644
--- a/pandas/tests/frame/methods/test_rename.py
+++ b/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
diff --git a/pandas/tests/frame/methods/test_rename_axis.py b/pandas/tests/frame/methods/test_rename_axis.py
index 9b964d842526c..3339119841813 100644
--- a/pandas/tests/frame/methods/test_rename_axis.py
+++ b/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)
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 498f7f7790514..ea72a3d8fef4d 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -27,7 +27,8 @@ def test_replace_inplace(self, datetime_frame, float_string_frame):
         datetime_frame["A"][-5:] = np.nan
 
         tsframe = datetime_frame.copy()
-        tsframe.replace(np.nan, 0, inplace=True)
+        return_value = tsframe.replace(np.nan, 0, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
 
         # mixed type
@@ -40,7 +41,8 @@ def test_replace_inplace(self, datetime_frame, float_string_frame):
         tm.assert_frame_equal(result, expected)
 
         tsframe = datetime_frame.copy()
-        tsframe.replace([np.nan], [0], inplace=True)
+        return_value = tsframe.replace([np.nan], [0], inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
 
     def test_regex_replace_scalar(self, mix_ab):
@@ -117,18 +119,21 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
         # regex -> value
         # obj frame
         res = dfobj.copy()
-        res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
+        return_value = res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
-        res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
+        return_value = res.replace(r"\s*\.\s*", np.nan, regex=True, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
         res = dfobj.copy()
-        res.replace(r"\s*(\.)\s*", r"\1\1\1", regex=True, inplace=True)
+        return_value = res.replace(r"\s*(\.)\s*", r"\1\1\1", regex=True, inplace=True)
+        assert return_value is None
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
@@ -136,7 +141,8 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # with mixed
         res = dfmix.copy()
-        res.replace(r"\s*(\.)\s*", r"\1\1\1", regex=True, inplace=True)
+        return_value = res.replace(r"\s*(\.)\s*", r"\1\1\1", regex=True, inplace=True)
+        assert return_value is None
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
@@ -144,18 +150,27 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # everything with compiled regexs as well
         res = dfobj.copy()
-        res.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True)
+        return_value = res.replace(
+            re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True
+        )
+        assert return_value is None
         tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
-        res.replace(re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True)
+        return_value = res.replace(
+            re.compile(r"\s*\.\s*"), np.nan, regex=True, inplace=True
+        )
+        assert return_value is None
         tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
         res = dfobj.copy()
-        res.replace(re.compile(r"\s*(\.)\s*"), r"\1\1\1", regex=True, inplace=True)
+        return_value = res.replace(
+            re.compile(r"\s*(\.)\s*"), r"\1\1\1", regex=True, inplace=True
+        )
+        assert return_value is None
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
@@ -163,25 +178,31 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # with mixed
         res = dfmix.copy()
-        res.replace(re.compile(r"\s*(\.)\s*"), r"\1\1\1", regex=True, inplace=True)
+        return_value = res.replace(
+            re.compile(r"\s*(\.)\s*"), r"\1\1\1", regex=True, inplace=True
+        )
+        assert return_value is None
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
         tm.assert_frame_equal(res, expec)
 
         res = dfobj.copy()
-        res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
+        return_value = res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
-        res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
+        return_value = res.replace(regex=r"\s*\.\s*", value=np.nan, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
         res = dfobj.copy()
-        res.replace(regex=r"\s*(\.)\s*", value=r"\1\1\1", inplace=True)
+        return_value = res.replace(regex=r"\s*(\.)\s*", value=r"\1\1\1", inplace=True)
+        assert return_value is None
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
@@ -189,7 +210,8 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # with mixed
         res = dfmix.copy()
-        res.replace(regex=r"\s*(\.)\s*", value=r"\1\1\1", inplace=True)
+        return_value = res.replace(regex=r"\s*(\.)\s*", value=r"\1\1\1", inplace=True)
+        assert return_value is None
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
@@ -197,18 +219,27 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # everything with compiled regexs as well
         res = dfobj.copy()
-        res.replace(regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True)
+        return_value = res.replace(
+            regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True
+        )
+        assert return_value is None
         tm.assert_frame_equal(dfobj, res.fillna("."))
 
         # mixed
         res = dfmix.copy()
-        res.replace(regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True)
+        return_value = res.replace(
+            regex=re.compile(r"\s*\.\s*"), value=np.nan, inplace=True
+        )
+        assert return_value is None
         tm.assert_frame_equal(dfmix, res.fillna("."))
 
         # regex -> regex
         # obj frame
         res = dfobj.copy()
-        res.replace(regex=re.compile(r"\s*(\.)\s*"), value=r"\1\1\1", inplace=True)
+        return_value = res.replace(
+            regex=re.compile(r"\s*(\.)\s*"), value=r"\1\1\1", inplace=True
+        )
+        assert return_value is None
         objc = obj.copy()
         objc["a"] = ["a", "b", "...", "..."]
         expec = DataFrame(objc)
@@ -216,7 +247,10 @@ def test_regex_replace_scalar_inplace(self, mix_ab):
 
         # with mixed
         res = dfmix.copy()
-        res.replace(regex=re.compile(r"\s*(\.)\s*"), value=r"\1\1\1", inplace=True)
+        return_value = res.replace(
+            regex=re.compile(r"\s*(\.)\s*"), value=r"\1\1\1", inplace=True
+        )
+        assert return_value is None
         mixc = mix_ab.copy()
         mixc["b"] = ["a", "b", "...", "..."]
         expec = DataFrame(mixc)
@@ -290,7 +324,8 @@ def test_regex_replace_list_obj_inplace(self):
         to_replace_res = [r"\s*\.\s*", r"e|f|g"]
         values = [np.nan, "crap"]
         res = dfobj.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame(
             {
                 "a": ["a", "b", np.nan, np.nan],
@@ -304,7 +339,8 @@ def test_regex_replace_list_obj_inplace(self):
         to_replace_res = [r"\s*(\.)\s*", r"(e|f|g)"]
         values = [r"\1\1", r"\1_crap"]
         res = dfobj.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame(
             {
                 "a": ["a", "b", "..", ".."],
@@ -319,7 +355,8 @@ def test_regex_replace_list_obj_inplace(self):
         to_replace_res = [r"\s*(\.)\s*", r"e"]
         values = [r"\1\1", r"crap"]
         res = dfobj.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame(
             {
                 "a": ["a", "b", "..", ".."],
@@ -332,7 +369,8 @@ def test_regex_replace_list_obj_inplace(self):
         to_replace_res = [r"\s*(\.)\s*", r"e"]
         values = [r"\1\1", r"crap"]
         res = dfobj.copy()
-        res.replace(value=values, regex=to_replace_res, inplace=True)
+        return_value = res.replace(value=values, regex=to_replace_res, inplace=True)
+        assert return_value is None
         expec = DataFrame(
             {
                 "a": ["a", "b", "..", ".."],
@@ -391,7 +429,8 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         to_replace_res = [r"\s*\.\s*", r"a"]
         values = [np.nan, "crap"]
         res = dfmix.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b", np.nan, np.nan]})
         tm.assert_frame_equal(res, expec)
 
@@ -399,7 +438,8 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         to_replace_res = [r"\s*(\.)\s*", r"(a|b)"]
         values = [r"\1\1", r"\1_crap"]
         res = dfmix.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame({"a": mix_ab["a"], "b": ["a_crap", "b_crap", "..", ".."]})
         tm.assert_frame_equal(res, expec)
 
@@ -408,14 +448,16 @@ def test_regex_replace_list_mixed_inplace(self, mix_ab):
         to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
         values = [r"\1\1", r"crap", r"\1_crap"]
         res = dfmix.copy()
-        res.replace(to_replace_res, values, inplace=True, regex=True)
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
         tm.assert_frame_equal(res, expec)
 
         to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
         values = [r"\1\1", r"crap", r"\1_crap"]
         res = dfmix.copy()
-        res.replace(regex=to_replace_res, value=values, inplace=True)
+        return_value = res.replace(regex=to_replace_res, value=values, inplace=True)
+        assert return_value is None
         expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
         tm.assert_frame_equal(res, expec)
 
@@ -430,7 +472,10 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         # frame
         res = dfmix.replace({"b": r"\s*\.\s*"}, {"b": np.nan}, regex=True)
         res2 = dfmix.copy()
-        res2.replace({"b": r"\s*\.\s*"}, {"b": np.nan}, inplace=True, regex=True)
+        return_value = res2.replace(
+            {"b": r"\s*\.\s*"}, {"b": np.nan}, inplace=True, regex=True
+        )
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
@@ -441,7 +486,10 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         # whole frame
         res = dfmix.replace({"b": r"\s*(\.)\s*"}, {"b": r"\1ty"}, regex=True)
         res2 = dfmix.copy()
-        res2.replace({"b": r"\s*(\.)\s*"}, {"b": r"\1ty"}, inplace=True, regex=True)
+        return_value = res2.replace(
+            {"b": r"\s*(\.)\s*"}, {"b": r"\1ty"}, inplace=True, regex=True
+        )
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
         )
@@ -450,7 +498,10 @@ def test_regex_replace_dict_mixed(self, mix_abc):
 
         res = dfmix.replace(regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"})
         res2 = dfmix.copy()
-        res2.replace(regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"}, inplace=True)
+        return_value = res2.replace(
+            regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"}, inplace=True
+        )
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
         )
@@ -464,13 +515,15 @@ def test_regex_replace_dict_mixed(self, mix_abc):
         )
         res = dfmix.replace("a", {"b": np.nan}, regex=True)
         res2 = dfmix.copy()
-        res2.replace("a", {"b": np.nan}, regex=True, inplace=True)
+        return_value = res2.replace("a", {"b": np.nan}, regex=True, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(res, expec)
         tm.assert_frame_equal(res2, expec)
 
         res = dfmix.replace("a", {"b": np.nan}, regex=True)
         res2 = dfmix.copy()
-        res2.replace(regex="a", value={"b": np.nan}, inplace=True)
+        return_value = res2.replace(regex="a", value={"b": np.nan}, inplace=True)
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": [np.nan, "b", ".", "."], "c": mix_abc["c"]}
         )
@@ -483,9 +536,13 @@ def test_regex_replace_dict_nested(self, mix_abc):
         res = dfmix.replace({"b": {r"\s*\.\s*": np.nan}}, regex=True)
         res2 = dfmix.copy()
         res4 = dfmix.copy()
-        res2.replace({"b": {r"\s*\.\s*": np.nan}}, inplace=True, regex=True)
+        return_value = res2.replace(
+            {"b": {r"\s*\.\s*": np.nan}}, inplace=True, regex=True
+        )
+        assert return_value is None
         res3 = dfmix.replace(regex={"b": {r"\s*\.\s*": np.nan}})
-        res4.replace(regex={"b": {r"\s*\.\s*": np.nan}}, inplace=True)
+        return_value = res4.replace(regex={"b": {r"\s*\.\s*": np.nan}}, inplace=True)
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
@@ -519,8 +576,14 @@ def test_regex_replace_list_to_scalar(self, mix_abc):
         res = df.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True)
         res2 = df.copy()
         res3 = df.copy()
-        res2.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True)
-        res3.replace(regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True)
+        return_value = res2.replace(
+            [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True
+        )
+        assert return_value is None
+        return_value = res3.replace(
+            regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True
+        )
+        assert return_value is None
         tm.assert_frame_equal(res, expec)
         tm.assert_frame_equal(res2, expec)
         tm.assert_frame_equal(res3, expec)
@@ -530,9 +593,11 @@ def test_regex_replace_str_to_numeric(self, mix_abc):
         df = DataFrame(mix_abc)
         res = df.replace(r"\s*\.\s*", 0, regex=True)
         res2 = df.copy()
-        res2.replace(r"\s*\.\s*", 0, inplace=True, regex=True)
+        return_value = res2.replace(r"\s*\.\s*", 0, inplace=True, regex=True)
+        assert return_value is None
         res3 = df.copy()
-        res3.replace(regex=r"\s*\.\s*", value=0, inplace=True)
+        return_value = res3.replace(regex=r"\s*\.\s*", value=0, inplace=True)
+        assert return_value is None
         expec = DataFrame({"a": mix_abc["a"], "b": ["a", "b", 0, 0], "c": mix_abc["c"]})
         tm.assert_frame_equal(res, expec)
         tm.assert_frame_equal(res2, expec)
@@ -542,9 +607,11 @@ def test_regex_replace_regex_list_to_numeric(self, mix_abc):
         df = DataFrame(mix_abc)
         res = df.replace([r"\s*\.\s*", "b"], 0, regex=True)
         res2 = df.copy()
-        res2.replace([r"\s*\.\s*", "b"], 0, regex=True, inplace=True)
+        return_value = res2.replace([r"\s*\.\s*", "b"], 0, regex=True, inplace=True)
+        assert return_value is None
         res3 = df.copy()
-        res3.replace(regex=[r"\s*\.\s*", "b"], value=0, inplace=True)
+        return_value = res3.replace(regex=[r"\s*\.\s*", "b"], value=0, inplace=True)
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", 0, 0, 0], "c": ["a", 0, np.nan, "d"]}
         )
@@ -558,9 +625,11 @@ def test_regex_replace_series_of_regexes(self, mix_abc):
         s2 = Series({"b": np.nan})
         res = df.replace(s1, s2, regex=True)
         res2 = df.copy()
-        res2.replace(s1, s2, inplace=True, regex=True)
+        return_value = res2.replace(s1, s2, inplace=True, regex=True)
+        assert return_value is None
         res3 = df.copy()
-        res3.replace(regex=s1, value=s2, inplace=True)
+        return_value = res3.replace(regex=s1, value=s2, inplace=True)
+        assert return_value is None
         expec = DataFrame(
             {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
         )
@@ -714,7 +783,8 @@ def test_replace_mixed(self, float_string_frame):
         result = df.replace(0, 0.5)
         tm.assert_frame_equal(result, expected)
 
-        df.replace(0, 0.5, inplace=True)
+        return_value = df.replace(0, 0.5, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(df, expected)
 
         # int block splitting
@@ -942,7 +1012,8 @@ def test_replace_input_formats_listlike(self):
         result = df.replace(to_rep, values)
         expected = df.copy()
         for i in range(len(to_rep)):
-            expected.replace(to_rep[i], values[i], inplace=True)
+            return_value = expected.replace(to_rep[i], values[i], inplace=True)
+            assert return_value is None
         tm.assert_frame_equal(result, expected)
 
         msg = r"Replacement lists must match in length\. Expecting 3 got 2"
@@ -969,7 +1040,8 @@ def test_replace_input_formats_scalar(self):
         result = df.replace(to_rep, -1)
         expected = df.copy()
         for i in range(len(to_rep)):
-            expected.replace(to_rep[i], -1, inplace=True)
+            return_value = expected.replace(to_rep[i], -1, inplace=True)
+            assert return_value is None
         tm.assert_frame_equal(result, expected)
 
     def test_replace_limit(self):
@@ -1321,7 +1393,8 @@ def test_categorical_replace_with_dict(self, replace_dict, final_data):
         with pytest.raises(AssertionError, match=msg):
             # ensure non-inplace call does not affect original
             tm.assert_frame_equal(df, expected)
-        df.replace(replace_dict, 3, inplace=True)
+        return_value = df.replace(replace_dict, 3, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/frame/methods/test_reset_index.py b/pandas/tests/frame/methods/test_reset_index.py
index cf0bbe144caa5..da4bfa9be4881 100644
--- a/pandas/tests/frame/methods/test_reset_index.py
+++ b/pandas/tests/frame/methods/test_reset_index.py
@@ -119,7 +119,8 @@ def test_reset_index(self, float_frame):
         # test resetting in place
         df = float_frame.copy()
         resetted = float_frame.reset_index()
-        df.reset_index(inplace=True)
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(df, resetted, check_names=False)
 
         df = float_frame.reset_index().set_index(["index", "A", "B"])
@@ -137,7 +138,8 @@ def test_reset_index_name(self):
         )
         assert df.reset_index().index.name is None
         assert df.reset_index(drop=True).index.name is None
-        df.reset_index(inplace=True)
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
         assert df.index.name is None
 
     def test_reset_index_level(self):
diff --git a/pandas/tests/frame/methods/test_set_index.py b/pandas/tests/frame/methods/test_set_index.py
index 5f62697cc3e43..ebe7eabd53b46 100644
--- a/pandas/tests/frame/methods/test_set_index.py
+++ b/pandas/tests/frame/methods/test_set_index.py
@@ -137,7 +137,8 @@ def test_set_index_drop_inplace(self, frame_of_index_cols, drop, inplace, keys):
 
         if inplace:
             result = df.copy()
-            result.set_index(keys, drop=drop, inplace=True)
+            return_value = result.set_index(keys, drop=drop, inplace=True)
+            assert return_value is None
         else:
             result = df.set_index(keys, drop=drop)
 
diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
index 543d87485d3c4..5216c3be116e0 100644
--- a/pandas/tests/frame/methods/test_sort_index.py
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -218,25 +218,29 @@ def test_sort_index_inplace(self):
         unordered = frame.loc[[3, 2, 4, 1]]
         a_id = id(unordered["A"])
         df = unordered.copy()
-        df.sort_index(inplace=True)
+        return_value = df.sort_index(inplace=True)
+        assert return_value is None
         expected = frame
         tm.assert_frame_equal(df, expected)
         assert a_id != id(df["A"])
 
         df = unordered.copy()
-        df.sort_index(ascending=False, inplace=True)
+        return_value = df.sort_index(ascending=False, inplace=True)
+        assert return_value is None
         expected = frame[::-1]
         tm.assert_frame_equal(df, expected)
 
         # axis=1
         unordered = frame.loc[:, ["D", "B", "C", "A"]]
         df = unordered.copy()
-        df.sort_index(axis=1, inplace=True)
+        return_value = df.sort_index(axis=1, inplace=True)
+        assert return_value is None
         expected = frame
         tm.assert_frame_equal(df, expected)
 
         df = unordered.copy()
-        df.sort_index(axis=1, ascending=False, inplace=True)
+        return_value = df.sort_index(axis=1, ascending=False, inplace=True)
+        assert return_value is None
         expected = frame.iloc[:, ::-1]
         tm.assert_frame_equal(df, expected)
 
@@ -589,7 +593,8 @@ def test_sort_index_level2(self):
 
         # inplace
         rs = frame.copy()
-        rs.sort_index(level=0, inplace=True)
+        return_value = rs.sort_index(level=0, inplace=True)
+        assert return_value is None
         tm.assert_frame_equal(rs, frame.sort_index(level=0))
 
     def test_sort_index_level_large_cardinality(self):
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index 1275da01eace9..c60e7e3b1bdb6 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -77,22 +77,28 @@ def test_sort_values_inplace(self):
         )
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", inplace=True)
+        return_value = sorted_df.sort_values(by="A", inplace=True)
+        assert return_value is None
         expected = frame.sort_values(by="A")
         tm.assert_frame_equal(sorted_df, expected)
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by=1, axis=1, inplace=True)
+        return_value = sorted_df.sort_values(by=1, axis=1, inplace=True)
+        assert return_value is None
         expected = frame.sort_values(by=1, axis=1)
         tm.assert_frame_equal(sorted_df, expected)
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", ascending=False, inplace=True)
+        return_value = sorted_df.sort_values(by="A", ascending=False, inplace=True)
+        assert return_value is None
         expected = frame.sort_values(by="A", ascending=False)
         tm.assert_frame_equal(sorted_df, expected)
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by=["A", "B"], ascending=False, inplace=True)
+        return_value = sorted_df.sort_values(
+            by=["A", "B"], ascending=False, inplace=True
+        )
+        assert return_value is None
         expected = frame.sort_values(by=["A", "B"], ascending=False)
         tm.assert_frame_equal(sorted_df, expected)
 
@@ -544,17 +550,24 @@ def test_sort_values_inplace_key(self, sort_by_key):
         )
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", inplace=True, key=sort_by_key)
+        return_value = sorted_df.sort_values(by="A", inplace=True, key=sort_by_key)
+        assert return_value is None
         expected = frame.sort_values(by="A", key=sort_by_key)
         tm.assert_frame_equal(sorted_df, expected)
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by=1, axis=1, inplace=True, key=sort_by_key)
+        return_value = sorted_df.sort_values(
+            by=1, axis=1, inplace=True, key=sort_by_key
+        )
+        assert return_value is None
         expected = frame.sort_values(by=1, axis=1, key=sort_by_key)
         tm.assert_frame_equal(sorted_df, expected)
 
         sorted_df = frame.copy()
-        sorted_df.sort_values(by="A", ascending=False, inplace=True, key=sort_by_key)
+        return_value = sorted_df.sort_values(
+            by="A", ascending=False, inplace=True, key=sort_by_key
+        )
+        assert return_value is None
         expected = frame.sort_values(by="A", ascending=False, key=sort_by_key)
         tm.assert_frame_equal(sorted_df, expected)
 
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index d5554860c034d..c9fec3215d57f 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -64,7 +64,8 @@ def test_consolidate(self, float_frame):
         float_frame["F"] = 8.0
         assert len(float_frame._mgr.blocks) == 3
 
-        float_frame._consolidate(inplace=True)
+        return_value = float_frame._consolidate(inplace=True)
+        assert return_value is None
         assert len(float_frame._mgr.blocks) == 1
 
     def test_consolidate_inplace(self, float_frame):
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index 98a2a33822e3b..628b955a1de92 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -413,7 +413,8 @@ def test_date_index_query(self):
         df = DataFrame(np.random.randn(n, 3))
         df["dates1"] = date_range("1/1/2012", periods=n)
         df["dates3"] = date_range("1/1/2014", periods=n)
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         res = df.query("index < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
         tm.assert_frame_equal(res, expec)
@@ -425,7 +426,8 @@ def test_date_index_query_with_NaT(self):
         df["dates1"] = date_range("1/1/2012", periods=n)
         df["dates3"] = date_range("1/1/2014", periods=n)
         df.iloc[0, 0] = pd.NaT
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         res = df.query("index < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index < "20130101") & ("20130101" < df.dates3)]
         tm.assert_frame_equal(res, expec)
@@ -438,7 +440,8 @@ def test_date_index_query_with_NaT_duplicates(self):
         d["dates3"] = date_range("1/1/2014", periods=n)
         df = DataFrame(d)
         df.loc[np.random.rand(n) > 0.5, "dates1"] = pd.NaT
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         res = df.query("dates1 < 20130101 < dates3", engine=engine, parser=parser)
         expec = df[(df.index.to_series() < "20130101") & ("20130101" < df.dates3)]
         tm.assert_frame_equal(res, expec)
@@ -759,7 +762,8 @@ def test_date_index_query(self):
         df = DataFrame(np.random.randn(n, 3))
         df["dates1"] = date_range("1/1/2012", periods=n)
         df["dates3"] = date_range("1/1/2014", periods=n)
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         res = df.query(
             "(index < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
@@ -773,7 +777,8 @@ def test_date_index_query_with_NaT(self):
         df["dates1"] = date_range("1/1/2012", periods=n)
         df["dates3"] = date_range("1/1/2014", periods=n)
         df.iloc[0, 0] = pd.NaT
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         res = df.query(
             "(index < 20130101) & (20130101 < dates3)", engine=engine, parser=parser
         )
@@ -787,7 +792,8 @@ def test_date_index_query_with_NaT_duplicates(self):
         df["dates1"] = date_range("1/1/2012", periods=n)
         df["dates3"] = date_range("1/1/2014", periods=n)
         df.loc[np.random.rand(n) > 0.5, "dates1"] = pd.NaT
-        df.set_index("dates1", inplace=True, drop=True)
+        return_value = df.set_index("dates1", inplace=True, drop=True)
+        assert return_value is None
         msg = r"'BoolOp' nodes are not implemented"
         with pytest.raises(NotImplementedError, match=msg):
             df.query("index < 20130101 < dates3", engine=engine, parser=parser)
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index 1634baacf6d6e..6a8f1e7c1aca2 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -473,7 +473,8 @@ def test_stack_ints(self):
         )
 
         df_named = df.copy()
-        df_named.columns.set_names(range(3), inplace=True)
+        return_value = df_named.columns.set_names(range(3), inplace=True)
+        assert return_value is None
 
         tm.assert_frame_equal(
             df_named.stack(level=[1, 2]), df_named.stack(level=1).stack(level=1)
diff --git a/pandas/tests/frame/test_to_csv.py b/pandas/tests/frame/test_to_csv.py
index 2b7b3af8f4705..db7347bb863a5 100644
--- a/pandas/tests/frame/test_to_csv.py
+++ b/pandas/tests/frame/test_to_csv.py
@@ -570,7 +570,8 @@ def test_to_csv_headers(self):
             from_df.to_csv(path, index=False, header=["X", "Y"])
             recons = self.read_csv(path)
 
-            recons.reset_index(inplace=True)
+            return_value = recons.reset_index(inplace=True)
+            assert return_value is None
             tm.assert_frame_equal(to_df, recons)
 
     def test_to_csv_multiindex(self, float_frame, datetime_frame):