Repository: pandas-dev/pandas

Issue:
DEPR: Deprecate method argument of reindex_like 
### Feature Type

- [X] Adding new functionality to pandas

- [X] Changing existing functionality in pandas

- [X] Removing existing functionality in pandas


### Problem Description

There is a bug report of this in https://github.com/pandas-dev/pandas/issues/34547 The current behavior of the method seems to work closer to DataFrame.update (whether intentional or not). Rather than try and fix I think it would be better to remove the parameter and have users call .fillna() or .update() to get the intended result

### Feature Description

Deprecate

### Alternative Solutions

N/A

### Additional Context

_No response_

Discussion:

Patch:
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 47446af728..f93e87074d 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -165,33 +165,23 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.Series.dt.tz_convert PR01,PR02" \
         -i "pandas.Series.dt.tz_localize PR01,PR02" \
         -i "pandas.Series.dt.unit GL08" \
-        -i "pandas.Series.eq PR07,SA01" \
-        -i "pandas.Series.floordiv PR07" \
-        -i "pandas.Series.ge PR07,SA01" \
-        -i "pandas.Series.gt PR07,SA01" \
+        -i "pandas.Series.eq SA01" \
+        -i "pandas.Series.ge SA01" \
+        -i "pandas.Series.gt SA01" \
         -i "pandas.Series.kurt RT03,SA01" \
         -i "pandas.Series.kurtosis RT03,SA01" \
-        -i "pandas.Series.le PR07,SA01" \
+        -i "pandas.Series.le SA01" \
         -i "pandas.Series.list.__getitem__ SA01" \
         -i "pandas.Series.list.flatten SA01" \
         -i "pandas.Series.list.len SA01" \
-        -i "pandas.Series.lt PR07,SA01" \
-        -i "pandas.Series.ne PR07,SA01" \
+        -i "pandas.Series.lt SA01" \
+        -i "pandas.Series.ne SA01" \
         -i "pandas.Series.pad PR01,SA01" \
         -i "pandas.Series.plot PR02,SA01" \
         -i "pandas.Series.pop RT03,SA01" \
-        -i "pandas.Series.pow PR07" \
         -i "pandas.Series.prod RT03" \
         -i "pandas.Series.product RT03" \
-        -i "pandas.Series.radd PR07" \
-        -i "pandas.Series.rdiv PR07" \
         -i "pandas.Series.reorder_levels RT03,SA01" \
-        -i "pandas.Series.rfloordiv PR07" \
-        -i "pandas.Series.rmod PR07" \
-        -i "pandas.Series.rmul PR07" \
-        -i "pandas.Series.rpow PR07" \
-        -i "pandas.Series.rsub PR07" \
-        -i "pandas.Series.rtruediv PR07" \
         -i "pandas.Series.sem PR01,RT03,SA01" \
         -i "pandas.Series.skew RT03,SA01" \
         -i "pandas.Series.sparse PR01,SA01" \
@@ -231,7 +221,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.Series.str.wrap RT03,SA01" \
         -i "pandas.Series.str.zfill RT03" \
         -i "pandas.Series.struct.dtypes SA01" \
-        -i "pandas.Series.sub PR07" \
         -i "pandas.Series.sum RT03" \
         -i "pandas.Series.swaplevel SA01" \
         -i "pandas.Series.to_dict SA01" \
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 0398d88da1..dc06dd9620 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -1511,7 +1511,6 @@ Currently, options unsupported by the C and pyarrow engines include:
 
 * ``sep`` other than a single character (e.g. regex separators)
 * ``skipfooter``
-* ``sep=None`` with ``delim_whitespace=False``
 
 Specifying any of the above options will produce a ``ParserWarning`` unless the
 python engine is selected explicitly using ``engine='python'``.
@@ -1526,7 +1525,6 @@ Options that are unsupported by the pyarrow engine which are not covered by the
 * ``memory_map``
 * ``dialect``
 * ``on_bad_lines``
-* ``delim_whitespace``
 * ``quoting``
 * ``lineterminator``
 * ``converters``
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 083e004fb9..f4ce36db32 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -206,6 +206,7 @@ Other Deprecations
 - Deprecated allowing non-keyword arguments in :meth:`Series.to_markdown` except ``buf``. (:issue:`57280`)
 - Deprecated allowing non-keyword arguments in :meth:`Series.to_string` except ``buf``. (:issue:`57280`)
 - Deprecated behavior of :meth:`Series.dt.to_pytimedelta`, in a future version this will return a :class:`Series` containing python ``datetime.timedelta`` objects instead of an ``ndarray`` of timedelta; this matches the behavior of other :meth:`Series.dt` properties. (:issue:`57463`)
+- Deprecated parameter ``method`` in :meth:`DataFrame.reindex_like` / :meth:`Series.reindex_like` (:issue:`58667`)
 - Deprecated using ``epoch`` date format in :meth:`DataFrame.to_json` and :meth:`Series.to_json`, use ``iso`` instead. (:issue:`57063`)
 -
 
@@ -243,7 +244,9 @@ Removal of prior version deprecations/changes
 - Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
 - Removed extension test classes ``BaseNoReduceTests``, ``BaseNumericReduceTests``, ``BaseBooleanReduceTests`` (:issue:`54663`)
 - Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
+- Removed the deprecated ``delim_whitespace`` keyword in :func:`read_csv` and :func:`read_table`, use ``sep=r"\s+"`` instead (:issue:`55569`)
 - Require :meth:`SparseDtype.fill_value` to be a valid value for the :meth:`SparseDtype.subtype` (:issue:`53043`)
+- Stopped performing dtype inference when setting a :class:`Index` into a :class:`DataFrame` (:issue:`56102`)
 - Stopped performing dtype inference with in :meth:`Index.insert` with object-dtype index; this often affects the index/columns that result when setting new entries into an empty :class:`Series` or :class:`DataFrame` (:issue:`51363`)
 - Removed the "closed" and "unit" keywords in :meth:`TimedeltaIndex.__new__` (:issue:`52628`, :issue:`55499`)
 - All arguments in :meth:`Index.sort_values` are now keyword only (:issue:`56493`)
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index 2718e9819c..f01d882224 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -38,7 +38,6 @@ from pandas.core.dtypes.common import (
     ensure_object,
     is_list_like,
     is_object_dtype,
-    is_string_dtype,
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import NumpyEADtype
@@ -555,9 +554,7 @@ def sanitize_array(
         # Avoid ending up with a NumpyExtensionArray
         dtype = dtype.numpy_dtype
 
-    object_index = False
-    if isinstance(data, ABCIndex) and data.dtype == object and dtype is None:
-        object_index = True
+    data_was_index = isinstance(data, ABCIndex)
 
     # extract ndarray or ExtensionArray, ensure we have no NumpyExtensionArray
     data = extract_array(data, extract_numpy=True, extract_range=True)
@@ -610,15 +607,8 @@ def sanitize_array(
 
         if dtype is None:
             subarr = data
-            if data.dtype == object:
+            if data.dtype == object and not data_was_index:
                 subarr = maybe_infer_to_datetimelike(data)
-                if (
-                    object_index
-                    and using_pyarrow_string_dtype()
-                    and is_string_dtype(subarr)
-                ):
-                    # Avoid inference when string option is set
-                    subarr = data
             elif data.dtype.kind == "U" and using_pyarrow_string_dtype():
                 from pandas.core.arrays.string_ import StringDtype
 
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a4decab6e8..9ede2c301c 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5059,22 +5059,7 @@ class DataFrame(NDFrame, OpsMixin):
 
         if is_list_like(value):
             com.require_length_match(value, self.index)
-        arr = sanitize_array(value, self.index, copy=True, allow_2d=True)
-        if (
-            isinstance(value, Index)
-            and value.dtype == "object"
-            and arr.dtype != value.dtype
-        ):  #
-            # TODO: Remove kludge in sanitize_array for string mode when enforcing
-            # this deprecation
-            warnings.warn(
-                "Setting an Index with object dtype into a DataFrame will stop "
-                "inferring another dtype in a future version. Cast the Index "
-                "explicitly before setting it into the DataFrame.",
-                FutureWarning,
-                stacklevel=find_stack_level(),
-            )
-        return arr, None
+        return sanitize_array(value, self.index, copy=True, allow_2d=True), None
 
     @property
     def _series(self):
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 3da047eaa2..0e91aa23fc 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -93,7 +93,10 @@ from pandas.errors import (
     InvalidIndexError,
 )
 from pandas.errors.cow import _chained_assignment_method_msg
-from pandas.util._decorators import doc
+from pandas.util._decorators import (
+    deprecate_kwarg,
+    doc,
+)
 from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import (
     check_dtype_backend,
@@ -4301,6 +4304,8 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
                 stacklevel=find_stack_level(),
             )
 
+    # issue 58667
+    @deprecate_kwarg("method", None)
     @final
     def reindex_like(
         self,
@@ -4328,6 +4333,8 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
             Please note: this is only applicable to DataFrames/Series with a
             monotonically increasing/decreasing index.
 
+            .. deprecated:: 3.0.0
+
             * None (default): don't fill gaps
             * pad / ffill: propagate last valid observation forward to next
               valid
diff --git a/pandas/core/ops/docstrings.py b/pandas/core/ops/docstrings.py
index 8063a52a02..0ad6db0aef 100644
--- a/pandas/core/ops/docstrings.py
+++ b/pandas/core/ops/docstrings.py
@@ -436,6 +436,7 @@ missing data in either one of the inputs.
 Parameters
 ----------
 other : Series or scalar value
+    The second operand in this operation.
 level : int or name
     Broadcast across a level, matching Index values on the
     passed MultiIndex level.
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 7348b616fa..97a53650ec 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -246,7 +246,7 @@ class Series(base.IndexOpsMixin, NDFrame):  # type: ignore[misc]
     ----------
     data : array-like, Iterable, dict, or scalar value
         Contains data stored in Series. If data is a dict, argument order is
-        maintained.
+        maintained. Unordered sets are not supported.
     index : array-like or Index (1d)
         Values must be hashable and have the same length as `data`.
         Non-unique index values are allowed. Will default to
diff --git a/pandas/errors/__init__.py b/pandas/errors/__init__.py
index f01fe8ecef..c8863e1b39 100644
--- a/pandas/errors/__init__.py
+++ b/pandas/errors/__init__.py
@@ -229,7 +229,6 @@ class ParserWarning(Warning):
 
     1. `sep` other than a single character (e.g. regex separators)
     2. `skipfooter` higher than 0
-    3. `sep=None` with `delim_whitespace=False`
 
     The warning can be avoided by adding `engine='python'` as a parameter in
     `pd.read_csv` and `pd.read_table` methods.
diff --git a/pandas/errors/cow.py b/pandas/errors/cow.py
index 1e7829c88a..4815a0f532 100644
--- a/pandas/errors/cow.py
+++ b/pandas/errors/cow.py
@@ -8,7 +8,7 @@ _chained_assignment_msg = (
     "the assignment in a single step.\n\n"
     "See the caveats in the documentation: "
     "https://pandas.pydata.org/pandas-docs/stable/user_guide/"
-    "indexing.html#returning-a-view-versus-a-copy"
+    "copy_on_write.html"
 )
 
 
diff --git a/pandas/io/clipboards.py b/pandas/io/clipboards.py
index aa20ec237e..5a0a8c321e 100644
--- a/pandas/io/clipboards.py
+++ b/pandas/io/clipboards.py
@@ -113,9 +113,8 @@ def read_clipboard(
         if index_length != 0:
             kwargs.setdefault("index_col", list(range(index_length)))
 
-    # Edge case where sep is specified to be None, return to default
-    if sep is None and kwargs.get("delim_whitespace") is None:
-        sep = r"\s+"
+    elif not isinstance(sep, str):
+        raise ValueError(f"{sep=} must be a string")
 
     # Regex separator currently only works with python engine.
     # Default to python if separator is multi-character (regex)
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index b2b0d711c6..69021eb265 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -3800,7 +3800,7 @@ def _validate_apply_axis_arg(
             f"operations is a Series with 'axis in [0,1]'"
         )
     if isinstance(arg, (Series, DataFrame)):  # align indx / cols to data
-        arg = arg.reindex_like(data, method=None).to_numpy(**dtype)
+        arg = arg.reindex_like(data).to_numpy(**dtype)
     else:
         arg = np.asarray(arg, **dtype)
         assert isinstance(arg, np.ndarray)  # mypy requirement
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index dd4f8ccde6..2ed4d8b669 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -133,7 +133,6 @@ if TYPE_CHECKING:
         encoding_errors: str | None
         dialect: str | csv.Dialect | None
         on_bad_lines: str
-        delim_whitespace: bool | lib.NoDefault
         low_memory: bool
         memory_map: bool
         float_precision: Literal["high", "legacy", "round_trip"] | None
@@ -425,14 +424,6 @@ on_bad_lines : {{'error', 'warn', 'skip'}} or Callable, default 'error'
 
         Callable for ``engine='pyarrow'``
 
-delim_whitespace : bool, default False
-    Specifies whether or not whitespace (e.g. ``' '`` or ``'\\t'``) will be
-    used as the ``sep`` delimiter. Equivalent to setting ``sep='\\s+'``. If this option
-    is set to ``True``, nothing should be passed in for the ``delimiter``
-    parameter.
-
-    .. deprecated:: 2.2.0
-        Use ``sep="\\s+"`` instead.
 low_memory : bool, default True
     Internally process the file in chunks, resulting in lower memory use
     while parsing, but possibly mixed type inference.  To ensure no mixed
@@ -558,7 +549,6 @@ dtype: object
 
 
 class _C_Parser_Defaults(TypedDict):
-    delim_whitespace: Literal[False]
     na_filter: Literal[True]
     low_memory: Literal[True]
     memory_map: Literal[False]
@@ -566,7 +556,6 @@ class _C_Parser_Defaults(TypedDict):
 
 
 _c_parser_defaults: _C_Parser_Defaults = {
-    "delim_whitespace": False,
     "na_filter": True,
     "low_memory": True,
     "memory_map": False,
@@ -592,7 +581,6 @@ _pyarrow_unsupported = {
     "thousands",
     "memory_map",
     "dialect",
-    "delim_whitespace",
     "quoting",
     "lineterminator",
     "converters",
@@ -818,24 +806,12 @@ def read_csv(
     # Error Handling
     on_bad_lines: str = "error",
     # Internal
-    delim_whitespace: bool | lib.NoDefault = lib.no_default,
     low_memory: bool = _c_parser_defaults["low_memory"],
     memory_map: bool = False,
     float_precision: Literal["high", "legacy", "round_trip"] | None = None,
     storage_options: StorageOptions | None = None,
     dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
 ) -> DataFrame | TextFileReader:
-    if delim_whitespace is not lib.no_default:
-        # GH#55569
-        warnings.warn(
-            "The 'delim_whitespace' keyword in pd.read_csv is deprecated and "
-            "will be removed in a future version. Use ``sep='\\s+'`` instead",
-            FutureWarning,
-            stacklevel=find_stack_level(),
-        )
-    else:
-        delim_whitespace = False
-
     # locals() should never be modified
     kwds = locals().copy()
     del kwds["filepath_or_buffer"]
@@ -844,7 +820,6 @@ def read_csv(
     kwds_defaults = _refine_defaults_read(
         dialect,
         delimiter,
-        delim_whitespace,
         engine,
         sep,
         on_bad_lines,
@@ -963,24 +938,12 @@ def read_table(
     # Error Handling
     on_bad_lines: str = "error",
     # Internal
-    delim_whitespace: bool | lib.NoDefault = lib.no_default,
     low_memory: bool = _c_parser_defaults["low_memory"],
     memory_map: bool = False,
     float_precision: Literal["high", "legacy", "round_trip"] | None = None,
     storage_options: StorageOptions | None = None,
     dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
 ) -> DataFrame | TextFileReader:
-    if delim_whitespace is not lib.no_default:
-        # GH#55569
-        warnings.warn(
-            "The 'delim_whitespace' keyword in pd.read_table is deprecated and "
-            "will be removed in a future version. Use ``sep='\\s+'`` instead",
-            FutureWarning,
-            stacklevel=find_stack_level(),
-        )
-    else:
-        delim_whitespace = False
-
     # locals() should never be modified
     kwds = locals().copy()
     del kwds["filepath_or_buffer"]
@@ -989,7 +952,6 @@ def read_table(
     kwds_defaults = _refine_defaults_read(
         dialect,
         delimiter,
-        delim_whitespace,
         engine,
         sep,
         on_bad_lines,
@@ -1296,17 +1258,10 @@ class TextFileReader(abc.Iterator):
                 engine = "python"
 
         sep = options["delimiter"]
-        delim_whitespace = options["delim_whitespace"]
 
-        if sep is None and not delim_whitespace:
-            if engine in ("c", "pyarrow"):
-                fallback_reason = (
-                    f"the '{engine}' engine does not support "
-                    "sep=None with delim_whitespace=False"
-                )
-                engine = "python"
-        elif sep is not None and len(sep) > 1:
+        if sep is not None and len(sep) > 1:
             if engine == "c" and sep == r"\s+":
+                # delim_whitespace passed on to pandas._libs.parsers.TextReader
                 result["delim_whitespace"] = True
                 del result["delimiter"]
             elif engine not in ("python", "python-fwf"):
@@ -1317,9 +1272,6 @@ class TextFileReader(abc.Iterator):
                     r"different from '\s+' are interpreted as regex)"
                 )
                 engine = "python"
-        elif delim_whitespace:
-            if "python" in engine:
-                result["delimiter"] = r"\s+"
         elif sep is not None:
             encodeable = True
             encoding = sys.getfilesystemencoding() or "utf-8"
@@ -1730,7 +1682,6 @@ def _stringify_na_values(na_values, floatify: bool) -> set[str | float]:
 def _refine_defaults_read(
     dialect: str | csv.Dialect | None,
     delimiter: str | None | lib.NoDefault,
-    delim_whitespace: bool,
     engine: CSVEngine | None,
     sep: str | None | lib.NoDefault,
     on_bad_lines: str | Callable,
@@ -1750,14 +1701,6 @@ def _refine_defaults_read(
         documentation for more details.
     delimiter : str or object
         Alias for sep.
-    delim_whitespace : bool
-        Specifies whether or not whitespace (e.g. ``' '`` or ``'\t'``) will be
-        used as the sep. Equivalent to setting ``sep='\\s+'``. If this option
-        is set to True, nothing should be passed in for the ``delimiter``
-        parameter.
-
-        .. deprecated:: 2.2.0
-            Use ``sep="\\s+"`` instead.
     engine : {{'c', 'python'}}
         Parser engine to use. The C engine is faster while the python engine is
         currently more feature-complete.
@@ -1777,12 +1720,6 @@ def _refine_defaults_read(
     -------
     kwds : dict
         Input parameters with correct values.
-
-    Raises
-    ------
-    ValueError :
-        If a delimiter was specified with ``sep`` (or ``delimiter``) and
-        ``delim_whitespace=True``.
     """
     # fix types for sep, delimiter to Union(str, Any)
     delim_default = defaults["delimiter"]
@@ -1813,12 +1750,6 @@ def _refine_defaults_read(
     if delimiter is None:
         delimiter = sep
 
-    if delim_whitespace and (delimiter is not lib.no_default):
-        raise ValueError(
-            "Specified a delimiter with both sep and "
-            "delim_whitespace=True; you can only specify one."
-        )
-
     if delimiter == "\n":
         raise ValueError(
             r"Specified \n as separator or delimiter. This forces the python engine "


Test patch:
diff --git a/pandas/conftest.py b/pandas/conftest.py
index e1225f031b..0ab5113952 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -158,6 +158,7 @@ def pytest_collection_modifyitems(items, config) -> None:
         ("SeriesGroupBy.idxmin", "The behavior of Series.idxmin"),
         ("SeriesGroupBy.idxmax", "The behavior of Series.idxmax"),
         ("to_pytimedelta", "The behavior of TimedeltaProperties.to_pytimedelta"),
+        ("NDFrame.reindex_like", "keyword argument 'method' is deprecated"),
         # Docstring divides by zero to show behavior difference
         ("missing.mask_zero_div_zero", "divide by zero encountered"),
         (
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index ed81e8c8b8..1fe11c6218 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -782,20 +782,18 @@ class TestDataFrameSetItem:
         df.iloc[:, 0] = Series([11], dtype="Int64")
         tm.assert_frame_equal(df, expected)
 
-    def test_setitem_object_inferring(self):
+    def test_setitem_index_object_dtype_not_inferring(self):
         # GH#56102
         idx = Index([Timestamp("2019-12-31")], dtype=object)
         df = DataFrame({"a": [1]})
-        with tm.assert_produces_warning(FutureWarning, match="infer"):
-            df.loc[:, "b"] = idx
-        with tm.assert_produces_warning(FutureWarning, match="infer"):
-            df["c"] = idx
+        df.loc[:, "b"] = idx
+        df["c"] = idx
 
         expected = DataFrame(
             {
                 "a": [1],
-                "b": Series([Timestamp("2019-12-31")], dtype="datetime64[ns]"),
-                "c": Series([Timestamp("2019-12-31")], dtype="datetime64[ns]"),
+                "b": idx,
+                "c": idx,
             }
         )
         tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/frame/methods/test_reindex_like.py b/pandas/tests/frame/methods/test_reindex_like.py
index ce68ec28ee..03968dcbb6 100644
--- a/pandas/tests/frame/methods/test_reindex_like.py
+++ b/pandas/tests/frame/methods/test_reindex_like.py
@@ -22,9 +22,11 @@ class TestDataFrameReindexLike:
     def test_reindex_like_methods(self, method, expected_values):
         df = DataFrame({"x": list(range(5))})
 
-        result = df.reindex_like(df, method=method, tolerance=0)
+        with tm.assert_produces_warning(FutureWarning):
+            result = df.reindex_like(df, method=method, tolerance=0)
         tm.assert_frame_equal(df, result)
-        result = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
+        with tm.assert_produces_warning(FutureWarning):
+            result = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
         tm.assert_frame_equal(df, result)
 
     def test_reindex_like_subclass(self):
diff --git a/pandas/tests/io/parser/common/test_common_basic.py b/pandas/tests/io/parser/common/test_common_basic.py
index d79e0c34ed..df76b46cc6 100644
--- a/pandas/tests/io/parser/common/test_common_basic.py
+++ b/pandas/tests/io/parser/common/test_common_basic.py
@@ -422,65 +422,43 @@ def test_read_empty_with_usecols(all_parsers, data, kwargs, expected):
 
 
 @pytest.mark.parametrize(
-    "kwargs,expected",
+    "kwargs,expected_data",
     [
         # gh-8661, gh-8679: this should ignore six lines, including
         # lines with trailing whitespace and blank lines.
         (
             {
                 "header": None,
-                "delim_whitespace": True,
+                "sep": r"\s+",
                 "skiprows": [0, 1, 2, 3, 5, 6],
                 "skip_blank_lines": True,
             },
-            DataFrame([[1.0, 2.0, 4.0], [5.1, np.nan, 10.0]]),
+            [[1.0, 2.0, 4.0], [5.1, np.nan, 10.0]],
         ),
         # gh-8983: test skipping set of rows after a row with trailing spaces.
         (
             {
-                "delim_whitespace": True,
+                "sep": r"\s+",
                 "skiprows": [1, 2, 3, 5, 6],
                 "skip_blank_lines": True,
             },
-            DataFrame({"A": [1.0, 5.1], "B": [2.0, np.nan], "C": [4.0, 10]}),
+            {"A": [1.0, 5.1], "B": [2.0, np.nan], "C": [4.0, 10]},
         ),
     ],
 )
-def test_trailing_spaces(all_parsers, kwargs, expected):
+def test_trailing_spaces(all_parsers, kwargs, expected_data):
     data = "A B C  \nrandom line with trailing spaces    \nskip\n1,2,3\n1,2.,4.\nrandom line with trailing tabs\t\t\t\n   \n5.1,NaN,10.0\n"  # noqa: E501
     parser = all_parsers
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-
     if parser.engine == "pyarrow":
-        msg = "The 'delim_whitespace' option is not supported with the 'pyarrow' engine"
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                FutureWarning, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
+        with pytest.raises(ValueError, match="the 'pyarrow' engine does not support"):
+            parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
         return
-
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
+    expected = DataFrame(expected_data)
+    result = parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
     tm.assert_frame_equal(result, expected)
 
 
-def test_raise_on_sep_with_delim_whitespace(all_parsers):
-    # see gh-6607
-    data = "a b c\n1 2 3"
-    parser = all_parsers
-
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with pytest.raises(ValueError, match="you can only specify one"):
-        with tm.assert_produces_warning(
-            FutureWarning, match=depr_msg, check_stacklevel=False
-        ):
-            parser.read_csv(StringIO(data), sep=r"\s", delim_whitespace=True)
-
-
 def test_read_filepath_or_buffer(all_parsers):
     # see gh-43366
     parser = all_parsers
@@ -489,8 +467,7 @@ def test_read_filepath_or_buffer(all_parsers):
         parser.read_csv(filepath_or_buffer=b"input")
 
 
-@pytest.mark.parametrize("delim_whitespace", [True, False])
-def test_single_char_leading_whitespace(all_parsers, delim_whitespace):
+def test_single_char_leading_whitespace(all_parsers):
     # see gh-9710
     parser = all_parsers
     data = """\
@@ -500,28 +477,16 @@ b
 a
 b\n"""
 
-    expected = DataFrame({"MyColumn": list("abab")})
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-
     if parser.engine == "pyarrow":
         msg = "The 'skipinitialspace' option is not supported with the 'pyarrow' engine"
         with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                FutureWarning, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_csv(
-                    StringIO(data),
-                    skipinitialspace=True,
-                    delim_whitespace=delim_whitespace,
-                )
+            parser.read_csv(
+                StringIO(data),
+                skipinitialspace=True,
+            )
         return
-
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_csv(
-            StringIO(data), skipinitialspace=True, delim_whitespace=delim_whitespace
-        )
+    expected = DataFrame({"MyColumn": list("abab")})
+    result = parser.read_csv(StringIO(data), skipinitialspace=True, sep=r"\s+")
     tm.assert_frame_equal(result, expected)
 
 
@@ -764,49 +729,6 @@ def test_read_csv_names_not_accepting_sets(all_parsers):
         parser.read_csv(StringIO(data), names=set("QAZ"))
 
 
-def test_read_table_delim_whitespace_default_sep(all_parsers):
-    # GH: 35958
-    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
-    parser = all_parsers
-
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_table is deprecated"
-
-    if parser.engine == "pyarrow":
-        msg = "The 'delim_whitespace' option is not supported with the 'pyarrow' engine"
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                FutureWarning, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_table(f, delim_whitespace=True)
-        return
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_table(f, delim_whitespace=True)
-    expected = DataFrame({"a": [1, 4], "b": [-2, 5], "c": [-3, 6]})
-    tm.assert_frame_equal(result, expected)
-
-
-@pytest.mark.parametrize("delimiter", [",", "\t"])
-def test_read_csv_delim_whitespace_non_default_sep(all_parsers, delimiter):
-    # GH: 35958
-    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
-    parser = all_parsers
-    msg = (
-        "Specified a delimiter with both sep and "
-        "delim_whitespace=True; you can only specify one."
-    )
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        with pytest.raises(ValueError, match=msg):
-            parser.read_csv(f, delim_whitespace=True, sep=delimiter)
-
-        with pytest.raises(ValueError, match=msg):
-            parser.read_csv(f, delim_whitespace=True, delimiter=delimiter)
-
-
 def test_read_csv_delimiter_and_sep_no_default(all_parsers):
     # GH#39823
     f = StringIO("a,b\n1,2")
@@ -832,26 +754,6 @@ def test_read_csv_line_break_as_separator(kwargs, all_parsers):
         parser.read_csv(StringIO(data), **kwargs)
 
 
-@pytest.mark.parametrize("delimiter", [",", "\t"])
-def test_read_table_delim_whitespace_non_default_sep(all_parsers, delimiter):
-    # GH: 35958
-    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
-    parser = all_parsers
-    msg = (
-        "Specified a delimiter with both sep and "
-        "delim_whitespace=True; you can only specify one."
-    )
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_table is deprecated"
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        with pytest.raises(ValueError, match=msg):
-            parser.read_table(f, delim_whitespace=True, sep=delimiter)
-
-        with pytest.raises(ValueError, match=msg):
-            parser.read_table(f, delim_whitespace=True, delimiter=delimiter)
-
-
 @skip_pyarrow
 def test_dict_keys_as_names(all_parsers):
     # GH: 36928
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index bd47e04541..ed2e729430 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -250,19 +250,17 @@ def test_null_byte_char(request, all_parsers):
 
 
 @pytest.mark.filterwarnings("always::ResourceWarning")
-def test_open_file(request, all_parsers):
+def test_open_file(all_parsers):
     # GH 39024
     parser = all_parsers
 
     msg = "Could not determine delimiter"
     err = csv.Error
     if parser.engine == "c":
-        msg = "the 'c' engine does not support sep=None with delim_whitespace=False"
-        err = ValueError
+        msg = "object of type 'NoneType' has no len"
+        err = TypeError
     elif parser.engine == "pyarrow":
-        msg = (
-            "the 'pyarrow' engine does not support sep=None with delim_whitespace=False"
-        )
+        msg = "'utf-8' codec can't decode byte 0xe4"
         err = ValueError
 
     with tm.ensure_clean() as path:
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index ab2e1ee138..39718ca2ec 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -53,11 +53,7 @@ def test_delim_whitespace_custom_terminator(c_parser_only):
     data = "a b c~1 2 3~4 5 6~7 8 9"
     parser = c_parser_only
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        df = parser.read_csv(StringIO(data), lineterminator="~", delim_whitespace=True)
+    df = parser.read_csv(StringIO(data), lineterminator="~", sep=r"\s+")
     expected = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["a", "b", "c"])
     tm.assert_frame_equal(df, expected)
 
diff --git a/pandas/tests/io/parser/test_comment.py b/pandas/tests/io/parser/test_comment.py
index ca8df520b1..ba27b170ae 100644
--- a/pandas/tests/io/parser/test_comment.py
+++ b/pandas/tests/io/parser/test_comment.py
@@ -31,10 +31,8 @@ def test_comment(all_parsers, na_values):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize(
-    "read_kwargs", [{}, {"lineterminator": "*"}, {"delim_whitespace": True}]
-)
-def test_line_comment(all_parsers, read_kwargs, request):
+@pytest.mark.parametrize("read_kwargs", [{}, {"lineterminator": "*"}, {"sep": r"\s+"}])
+def test_line_comment(all_parsers, read_kwargs):
     parser = all_parsers
     data = """# empty
 A,B,C
@@ -42,12 +40,8 @@ A,B,C
 #ignore this line
 5.,NaN,10.0
 """
-    warn = None
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-
-    if read_kwargs.get("delim_whitespace"):
+    if read_kwargs.get("sep"):
         data = data.replace(",", " ")
-        warn = FutureWarning
     elif read_kwargs.get("lineterminator"):
         data = data.replace("\n", read_kwargs.get("lineterminator"))
 
@@ -60,23 +54,15 @@ A,B,C
         else:
             msg = "The 'comment' option is not supported with the 'pyarrow' engine"
         with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                warn, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_csv(StringIO(data), **read_kwargs)
+            parser.read_csv(StringIO(data), **read_kwargs)
         return
     elif parser.engine == "python" and read_kwargs.get("lineterminator"):
         msg = r"Custom line terminators not supported in python parser \(yet\)"
         with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                warn, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_csv(StringIO(data), **read_kwargs)
+            parser.read_csv(StringIO(data), **read_kwargs)
         return
 
-    with tm.assert_produces_warning(warn, match=depr_msg, check_stacklevel=False):
-        result = parser.read_csv(StringIO(data), **read_kwargs)
-
+    result = parser.read_csv(StringIO(data), **read_kwargs)
     expected = DataFrame(
         [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0]], columns=["A", "B", "C"]
     )
diff --git a/pandas/tests/io/parser/test_header.py b/pandas/tests/io/parser/test_header.py
index 85ce55b3bc..b7e3a13ec2 100644
--- a/pandas/tests/io/parser/test_header.py
+++ b/pandas/tests/io/parser/test_header.py
@@ -682,7 +682,7 @@ def test_header_missing_rows(all_parsers):
         parser.read_csv(StringIO(data), header=[0, 1, 2])
 
 
-# ValueError: The 'delim_whitespace' option is not supported with the 'pyarrow' engine
+# ValueError: the 'pyarrow' engine does not support regex separators
 @xfail_pyarrow
 def test_header_multiple_whitespaces(all_parsers):
     # GH#54931
@@ -695,7 +695,7 @@ def test_header_multiple_whitespaces(all_parsers):
     tm.assert_frame_equal(result, expected)
 
 
-# ValueError: The 'delim_whitespace' option is not supported with the 'pyarrow' engine
+# ValueError: the 'pyarrow' engine does not support regex separators
 @xfail_pyarrow
 def test_header_delim_whitespace(all_parsers):
     # GH#54918
@@ -704,12 +704,7 @@ def test_header_delim_whitespace(all_parsers):
 1,2
 3,4
     """
-
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_csv(StringIO(data), delim_whitespace=True)
+    result = parser.read_csv(StringIO(data), sep=r"\s+")
     expected = DataFrame({"a,b": ["1,2", "3,4"]})
     tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/io/parser/test_read_fwf.py b/pandas/tests/io/parser/test_read_fwf.py
index 547afb1b25..0a9f6bd83e 100644
--- a/pandas/tests/io/parser/test_read_fwf.py
+++ b/pandas/tests/io/parser/test_read_fwf.py
@@ -580,10 +580,7 @@ DataCol1   DataCol2
 """.strip()
     skiprows = 2
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=depr_msg):
-        expected = read_csv(StringIO(data), skiprows=skiprows, delim_whitespace=True)
-
+    expected = read_csv(StringIO(data), skiprows=skiprows, sep=r"\s+")
     result = read_fwf(StringIO(data), skiprows=skiprows)
     tm.assert_frame_equal(result, expected)
 
@@ -598,10 +595,7 @@ Once more to be skipped
 """.strip()
     skiprows = [0, 2]
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(FutureWarning, match=depr_msg):
-        expected = read_csv(StringIO(data), skiprows=skiprows, delim_whitespace=True)
-
+    expected = read_csv(StringIO(data), skiprows=skiprows, sep=r"\s+")
     result = read_fwf(StringIO(data), skiprows=skiprows)
     tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/io/parser/test_skiprows.py b/pandas/tests/io/parser/test_skiprows.py
index 3cd2351f84..17a806d05f 100644
--- a/pandas/tests/io/parser/test_skiprows.py
+++ b/pandas/tests/io/parser/test_skiprows.py
@@ -187,7 +187,7 @@ def test_skip_row_with_newline_and_quote(all_parsers, data, exp_data):
     tm.assert_frame_equal(result, expected)
 
 
-@xfail_pyarrow  # ValueError: The 'delim_whitespace' option is not supported
+@xfail_pyarrow  # ValueError: the 'pyarrow' engine does not support regex separators
 @pytest.mark.parametrize(
     "lineterminator",
     ["\n", "\r\n", "\r"],  # "LF"  # "CRLF"  # "CR"
@@ -218,16 +218,12 @@ def test_skiprows_lineterminator(all_parsers, lineterminator, request):
 
     data = data.replace("\n", lineterminator)
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_csv(
-            StringIO(data),
-            skiprows=1,
-            delim_whitespace=True,
-            names=["date", "time", "var", "flag", "oflag"],
-        )
+    result = parser.read_csv(
+        StringIO(data),
+        skiprows=1,
+        sep=r"\s+",
+        names=["date", "time", "var", "flag", "oflag"],
+    )
     tm.assert_frame_equal(result, expected)
 
 
diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index 44a55cf3be..07f84466e3 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -44,12 +44,7 @@ class TestUnsupportedFeatures:
         data = "a b c\n1 2 3"
         msg = "does not support"
 
-        depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-
         # specify C engine with unsupported options (raise)
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(FutureWarning, match=depr_msg):
-                read_csv(StringIO(data), engine="c", sep=None, delim_whitespace=False)
         with pytest.raises(ValueError, match=msg):
             read_csv(StringIO(data), engine="c", sep=r"\s")
         with pytest.raises(ValueError, match=msg):
@@ -58,8 +53,6 @@ class TestUnsupportedFeatures:
             read_csv(StringIO(data), engine="c", skipfooter=1)
 
         # specify C-unsupported options without python-unsupported options
-        with tm.assert_produces_warning((parsers.ParserWarning, FutureWarning)):
-            read_csv(StringIO(data), sep=None, delim_whitespace=False)
         with tm.assert_produces_warning(parsers.ParserWarning):
             read_csv(StringIO(data), sep=r"\s")
         with tm.assert_produces_warning(parsers.ParserWarning):
@@ -154,14 +147,8 @@ x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
             elif default == "on_bad_lines":
                 kwargs[default] = "warn"
 
-            warn = None
-            depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-            if "delim_whitespace" in kwargs:
-                warn = FutureWarning
-
             with pytest.raises(ValueError, match=msg):
-                with tm.assert_produces_warning(warn, match=depr_msg):
-                    read_csv(StringIO(data), engine="pyarrow", **kwargs)
+                read_csv(StringIO(data), engine="pyarrow", **kwargs)
 
     def test_on_bad_lines_callable_python_or_pyarrow(self, all_parsers):
         # GH 5686
diff --git a/pandas/tests/io/parser/usecols/test_usecols_basic.py b/pandas/tests/io/parser/usecols/test_usecols_basic.py
index d55066d2d7..82b42beb38 100644
--- a/pandas/tests/io/parser/usecols/test_usecols_basic.py
+++ b/pandas/tests/io/parser/usecols/test_usecols_basic.py
@@ -158,7 +158,8 @@ def test_usecols_single_string(all_parsers):
         parser.read_csv(StringIO(data), usecols="foo")
 
 
-@skip_pyarrow  # CSV parse error in one case, AttributeError in another
+# ArrowKeyError: Column 'a' in include_columns does not exist in CSV file
+@skip_pyarrow
 @pytest.mark.parametrize(
     "data", ["a,b,c,d\n1,2,3,4\n5,6,7,8", "a,b,c,d\n1,2,3,4,\n5,6,7,8,"]
 )
@@ -254,29 +255,12 @@ def test_usecols_regex_sep(all_parsers):
     tm.assert_frame_equal(result, expected)
 
 
+@skip_pyarrow  # Column 'a' in include_columns does not exist in CSV file
 def test_usecols_with_whitespace(all_parsers):
     parser = all_parsers
     data = "a  b  c\n4  apple  bat  5.7\n8  orange  cow  10"
 
-    depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
-
-    if parser.engine == "pyarrow":
-        msg = "The 'delim_whitespace' option is not supported with the 'pyarrow' engine"
-        with pytest.raises(ValueError, match=msg):
-            with tm.assert_produces_warning(
-                FutureWarning, match=depr_msg, check_stacklevel=False
-            ):
-                parser.read_csv(
-                    StringIO(data), delim_whitespace=True, usecols=("a", "b")
-                )
-        return
-
-    with tm.assert_produces_warning(
-        FutureWarning, match=depr_msg, check_stacklevel=False
-    ):
-        result = parser.read_csv(
-            StringIO(data), delim_whitespace=True, usecols=("a", "b")
-        )
+    result = parser.read_csv(StringIO(data), sep=r"\s+", usecols=("a", "b"))
     expected = DataFrame({"a": ["apple", "orange"], "b": ["bat", "cow"]}, index=[4, 8])
     tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 5ee9b65ba9..c38d223c9d 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1300,7 +1300,8 @@ def test_resample_consistency(unit):
 
     s10 = s.reindex(index=i10, method="bfill")
     s10_2 = s.reindex(index=i10, method="bfill", limit=2)
-    rl = s.reindex_like(s10, method="bfill", limit=2)
+    with tm.assert_produces_warning(FutureWarning):
+        rl = s.reindex_like(s10, method="bfill", limit=2)
     r10_2 = s.resample("10Min").bfill(limit=2)
     r10 = s.resample("10Min").bfill()
 
diff --git a/pandas/tests/series/methods/test_reindex_like.py b/pandas/tests/series/methods/test_reindex_like.py
index 7f24c778fe..10b8ac5817 100644
--- a/pandas/tests/series/methods/test_reindex_like.py
+++ b/pandas/tests/series/methods/test_reindex_like.py
@@ -20,7 +20,8 @@ def test_reindex_like(datetime_series):
     series1 = Series([5, None, None], [day1, day2, day3])
     series2 = Series([None, None], [day1, day3])
 
-    result = series1.reindex_like(series2, method="pad")
+    with tm.assert_produces_warning(FutureWarning):
+        result = series1.reindex_like(series2, method="pad")
     expected = Series([5, np.nan], index=[day1, day3])
     tm.assert_series_equal(result, expected)
 
@@ -32,10 +33,13 @@ def test_reindex_like_nearest():
     other = ser.reindex(target, method="nearest")
     expected = Series(np.around(target).astype("int64"), target)
 
-    result = ser.reindex_like(other, method="nearest")
+    with tm.assert_produces_warning(FutureWarning):
+        result = ser.reindex_like(other, method="nearest")
     tm.assert_series_equal(expected, result)
 
-    result = ser.reindex_like(other, method="nearest", tolerance=1)
+    with tm.assert_produces_warning(FutureWarning):
+        result = ser.reindex_like(other, method="nearest", tolerance=1)
     tm.assert_series_equal(expected, result)
-    result = ser.reindex_like(other, method="nearest", tolerance=[1, 2, 3, 4])
+    with tm.assert_produces_warning(FutureWarning):
+        result = ser.reindex_like(other, method="nearest", tolerance=[1, 2, 3, 4])
     tm.assert_series_equal(expected, result)