diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 2e1ebf9d5a266..a8cc07c8fd964 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1466,8 +1466,6 @@ def max(self, *, axis: int | None = None, skipna: bool = True, **kwargs):
         Index.max : Return the maximum value in an Index.
         Series.max : Return the maximum value in a Series.
         """
-        # TODO: skipna is broken with max.
-        # See https://github.com/pandas-dev/pandas/issues/24265
         nv.validate_max((), kwargs)
         nv.validate_minmax_axis(axis, self.ndim)
 
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index 568f3484e78e4..34aaf054de48e 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -605,7 +605,7 @@ def value_counts(self, dropna: bool = True) -> Series:
         data = self._data[~self._mask]
         value_counts = Index(data).value_counts()
 
-        # TODO(extension)
+        # TODO(ExtensionIndex)
         # if we have allow Index to hold an ExtensionArray
         # this is easier
         index = value_counts.index._values.astype(object)
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index b8354e800753d..4535010b29c3a 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -1039,7 +1039,7 @@ def _wrap_applied_output_series(
         key_index,
     ) -> DataFrame | Series:
         # this is to silence a DeprecationWarning
-        # TODO: Remove when default dtype of empty Series is object
+        # TODO(2.0): Remove when default dtype of empty Series is object
         kwargs = first_not_none._construct_axes_dict()
         backup = create_series_with_explicit_dtype(dtype_if_empty=object, **kwargs)
         values = [x if (x is not None) else backup for x in values]
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 00c4d2778e545..97f5ef20c5c5e 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -3337,7 +3337,8 @@ def pct_change(self, periods=1, fill_method="pad", limit=None, freq=None, axis=0
         Series or DataFrame
             Percentage changes within each group.
         """
-        # TODO: Remove this conditional for SeriesGroupBy when GH#23918 is fixed
+        # TODO(GH#23918): Remove this conditional for SeriesGroupBy when
+        #  GH#23918 is fixed
         if freq is not None or axis != 0:
             return self.apply(
                 lambda x: x.pct_change(
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 60c8851f059fe..8223a04883738 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -868,8 +868,8 @@ def result_arraylike(self) -> ArrayLike:
         Analogous to result_index, but returning an ndarray/ExtensionArray
         allowing us to retain ExtensionDtypes not supported by Index.
         """
-        # TODO: once Index supports arbitrary EAs, this can be removed in favor
-        #  of result_index
+        # TODO(ExtensionIndex): once Index supports arbitrary EAs, this can
+        #  be removed in favor of result_index
         if len(self.groupings) == 1:
             return self.groupings[0].group_arraylike
 
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index e77cdd7ad7369..74d785586b950 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -80,8 +80,6 @@
     operate_blockwise,
 )
 
-# TODO: flexible with index=None and/or items=None
-
 T = TypeVar("T", bound="BaseBlockManager")
 
 
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index a95592c96d411..10d95dfbb9181 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -1781,16 +1781,20 @@ def na_accum_func(values: ArrayLike, accum_func, *, skipna: bool) -> ArrayLike:
         # We need to define mask before masking NaTs
         mask = isna(values)
 
-        if accum_func == np.minimum.accumulate:
-            # Note: the accum_func comparison fails as an "is" comparison
-            y = values.view("i8")
-            y[mask] = lib.i8max
-            changed = True
-        else:
-            y = values
-            changed = False
+        y = values.view("i8")
+        # Note: the accum_func comparison fails as an "is" comparison
+        changed = accum_func == np.minimum.accumulate
+
+        try:
+            if changed:
+                y[mask] = lib.i8max
+
+            result = accum_func(y, axis=0)
+        finally:
+            if changed:
+                # restore NaT elements
+                y[mask] = iNaT
 
-        result = accum_func(y.view("i8"), axis=0)
         if skipna:
             result[mask] = iNaT
         elif accum_func == np.minimum.accumulate:
@@ -1800,10 +1804,6 @@ def na_accum_func(values: ArrayLike, accum_func, *, skipna: bool) -> ArrayLike:
                 # everything up to the first non-na entry stays NaT
                 result[: nz[0]] = iNaT
 
-        if changed:
-            # restore NaT elements
-            y[mask] = iNaT  # TODO: could try/finally for this?
-
         if isinstance(values.dtype, np.dtype):
             result = result.view(orig_dtype)
         else:
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 300df9728cd75..38b42f4470058 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -103,13 +103,14 @@ class _Column:
     col_id: int
     name: str | bytes
     label: str | bytes
-    format: str | bytes  # TODO: i think allowing bytes is from py2 days
+    format: str | bytes
     ctype: bytes
     length: int
 
     def __init__(
         self,
         col_id: int,
+        # These can be bytes when convert_header_text is False
         name: str | bytes,
         label: str | bytes,
         format: str | bytes,
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 75cabf1681bc7..4be54ceaa2bcf 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -2158,9 +2158,6 @@ def to_sql(
         table.insert(chunksize, method)
 
     def has_table(self, name: str, schema: str | None = None):
-        # TODO(wesm): unused?
-        # escape = _get_valid_sqlite_name
-        # esc_name = escape(name)
 
         wld = "?"
         query = f"SELECT name FROM sqlite_master WHERE type='table' AND name={wld};"
diff --git a/pandas/tests/apply/test_series_apply.py b/pandas/tests/apply/test_series_apply.py
index 1d0b64c1835df..b7084e2bc6dc7 100644
--- a/pandas/tests/apply/test_series_apply.py
+++ b/pandas/tests/apply/test_series_apply.py
@@ -794,18 +794,15 @@ def test_apply_to_timedelta():
     list_of_valid_strings = ["00:00:01", "00:00:02"]
     a = pd.to_timedelta(list_of_valid_strings)
     b = Series(list_of_valid_strings).apply(pd.to_timedelta)
-    # FIXME: dont leave commented-out
-    # Can't compare until apply on a Series gives the correct dtype
-    # assert_series_equal(a, b)
+    tm.assert_series_equal(Series(a), b)
 
     list_of_strings = ["00:00:01", np.nan, pd.NaT, pd.NaT]
 
-    a = pd.to_timedelta(list_of_strings)  # noqa
+    a = pd.to_timedelta(list_of_strings)
     with tm.assert_produces_warning(FutureWarning, match="Inferring timedelta64"):
         ser = Series(list_of_strings)
-    b = ser.apply(pd.to_timedelta)  # noqa
-    # Can't compare until apply on a Series gives the correct dtype
-    # assert_series_equal(a, b)
+    b = ser.apply(pd.to_timedelta)
+    tm.assert_series_equal(Series(a), b)
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/arrays/floating/test_arithmetic.py b/pandas/tests/arrays/floating/test_arithmetic.py
index e674b49a99bd4..5d959b9224e52 100644
--- a/pandas/tests/arrays/floating/test_arithmetic.py
+++ b/pandas/tests/arrays/floating/test_arithmetic.py
@@ -142,17 +142,16 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     with pytest.raises(TypeError, match=msg):
         ops(pd.Series("foo", index=s.index))
 
-    if op != "__rpow__":
-        # TODO(extension)
-        # rpow with a datetimelike coerces the integer array incorrectly
-        msg = (
-            "can only perform ops with numeric values|"
-            "cannot perform .* with this index type: DatetimeArray|"
+    msg = "|".join(
+        [
+            "can only perform ops with numeric values",
+            "cannot perform .* with this index type: DatetimeArray",
             "Addition/subtraction of integers and integer-arrays "
-            "with DatetimeArray is no longer supported. *"
-        )
-        with pytest.raises(TypeError, match=msg):
-            ops(pd.Series(pd.date_range("20180101", periods=len(s))))
+            "with DatetimeArray is no longer supported. *",
+        ]
+    )
+    with pytest.raises(TypeError, match=msg):
+        ops(pd.Series(pd.date_range("20180101", periods=len(s))))
 
 
 # Various
diff --git a/pandas/tests/arrays/integer/test_arithmetic.py b/pandas/tests/arrays/integer/test_arithmetic.py
index 4f66e2ecfd355..5a5d047996747 100644
--- a/pandas/tests/arrays/integer/test_arithmetic.py
+++ b/pandas/tests/arrays/integer/test_arithmetic.py
@@ -179,17 +179,16 @@ def test_error_invalid_values(data, all_arithmetic_operators):
     with pytest.raises(TypeError, match=msg):
         ops(pd.Series("foo", index=s.index))
 
-    if op != "__rpow__":
-        # TODO(extension)
-        # rpow with a datetimelike coerces the integer array incorrectly
-        msg = (
-            "can only perform ops with numeric values|"
-            "cannot perform .* with this index type: DatetimeArray|"
+    msg = "|".join(
+        [
+            "can only perform ops with numeric values",
+            "cannot perform .* with this index type: DatetimeArray",
             "Addition/subtraction of integers and integer-arrays "
-            "with DatetimeArray is no longer supported. *"
-        )
-        with pytest.raises(TypeError, match=msg):
-            ops(pd.Series(pd.date_range("20180101", periods=len(s))))
+            "with DatetimeArray is no longer supported. *",
+        ]
+    )
+    with pytest.raises(TypeError, match=msg):
+        ops(pd.Series(pd.date_range("20180101", periods=len(s))))
 
 
 # Various
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 5b9df44f5b565..0453b1ef1c40d 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -33,9 +33,13 @@ def test_cmp_dt64_arraylike_tznaive(self, comparison_op):
 
         result = op(arr, arr)
         tm.assert_numpy_array_equal(result, expected)
-        for other in [right, np.array(right)]:
-            # TODO: add list and tuple, and object-dtype once those
-            #  are fixed in the constructor
+        for other in [
+            right,
+            np.array(right),
+            list(right),
+            tuple(right),
+            right.astype(object),
+        ]:
             result = op(arr, other)
             tm.assert_numpy_array_equal(result, expected)
 
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 1ddb18c218cc6..6927a5927ef48 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -925,8 +925,8 @@ def test_binop_other(self, op, value, dtype, switch_numexpr_min_elements):
             (operator.mul, "bool"),
         }
 
-        e = DummyElement(value, dtype)
-        s = DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+        elem = DummyElement(value, dtype)
+        df = DataFrame({"A": [elem.value, elem.value]}, dtype=elem.dtype)
 
         invalid = {
             (operator.pow, "<M8[ns]"),
@@ -960,7 +960,7 @@ def test_binop_other(self, op, value, dtype, switch_numexpr_min_elements):
 
             with pytest.raises(TypeError, match=msg):
                 with tm.assert_produces_warning(warn):
-                    op(s, e.value)
+                    op(df, elem.value)
 
         elif (op, dtype) in skip:
 
@@ -971,19 +971,17 @@ def test_binop_other(self, op, value, dtype, switch_numexpr_min_elements):
                 else:
                     warn = None
                 with tm.assert_produces_warning(warn):
-                    op(s, e.value)
+                    op(df, elem.value)
 
             else:
                 msg = "operator '.*' not implemented for .* dtypes"
                 with pytest.raises(NotImplementedError, match=msg):
-                    op(s, e.value)
+                    op(df, elem.value)
 
         else:
-            # FIXME: Since dispatching to Series, this test no longer
-            # asserts anything meaningful
             with tm.assert_produces_warning(None):
-                result = op(s, e.value).dtypes
-                expected = op(s, value).dtypes
+                result = op(df, elem.value).dtypes
+                expected = op(df, value).dtypes
             tm.assert_series_equal(result, expected)
 
 
@@ -1240,9 +1238,7 @@ def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
         added = float_frame + mixed_int_frame
         _check_mixed_float(added, dtype="float64")
 
-    def test_combine_series(
-        self, float_frame, mixed_float_frame, mixed_int_frame, datetime_frame
-    ):
+    def test_combine_series(self, float_frame, mixed_float_frame, mixed_int_frame):
 
         # Series
         series = float_frame.xs(float_frame.index[0])
@@ -1272,17 +1268,18 @@ def test_combine_series(
         added = mixed_float_frame + series.astype("float16")
         _check_mixed_float(added, dtype={"C": None})
 
-        # FIXME: don't leave commented-out
-        # these raise with numexpr.....as we are adding an int64 to an
-        # uint64....weird vs int
-
-        # added = mixed_int_frame + (100*series).astype('int64')
-        # _check_mixed_int(added, dtype = {"A": 'int64', "B": 'float64', "C":
-        # 'int64', "D": 'int64'})
-        # added = mixed_int_frame + (100*series).astype('int32')
-        # _check_mixed_int(added, dtype = {"A": 'int32', "B": 'float64', "C":
-        # 'int32', "D": 'int64'})
+        # these used to raise with numexpr as we are adding an int64 to an
+        #  uint64....weird vs int
+        added = mixed_int_frame + (100 * series).astype("int64")
+        _check_mixed_int(
+            added, dtype={"A": "int64", "B": "float64", "C": "int64", "D": "int64"}
+        )
+        added = mixed_int_frame + (100 * series).astype("int32")
+        _check_mixed_int(
+            added, dtype={"A": "int32", "B": "float64", "C": "int32", "D": "int64"}
+        )
 
+    def test_combine_timeseries(self, datetime_frame):
         # TimeSeries
         ts = datetime_frame["A"]
 
diff --git a/pandas/tests/indexes/datetimes/methods/test_insert.py b/pandas/tests/indexes/datetimes/methods/test_insert.py
index 016a29e4cc266..592f4240ee750 100644
--- a/pandas/tests/indexes/datetimes/methods/test_insert.py
+++ b/pandas/tests/indexes/datetimes/methods/test_insert.py
@@ -236,7 +236,6 @@ def test_insert_mismatched_types_raises(self, tz_aware_fixture, item):
         result = dti.insert(1, item)
 
         if isinstance(item, np.ndarray):
-            # FIXME: without doing .item() here this segfaults
             assert item.item() == 0
             expected = Index([dti[0], 0] + list(dti[1:]), dtype=object, name=9)
         else:
diff --git a/pandas/tests/indexes/multi/test_formats.py b/pandas/tests/indexes/multi/test_formats.py
index 17699aa32929e..a6dadd42f7bf0 100644
--- a/pandas/tests/indexes/multi/test_formats.py
+++ b/pandas/tests/indexes/multi/test_formats.py
@@ -87,10 +87,7 @@ def test_unicode_repr_issues(self):
         index = MultiIndex(levels=levels, codes=codes)
 
         repr(index.levels)
-
-        # FIXME: dont leave commented-out
-        # NumPy bug
-        # repr(index.get_level_values(1))
+        repr(index.get_level_values(1))
 
     def test_repr_max_seq_items_equal_to_n(self, idx):
         # display.max_seq_items == n
diff --git a/pandas/tests/series/methods/test_convert.py b/pandas/tests/series/methods/test_convert.py
index b658929dfd0d5..178026c1efc09 100644
--- a/pandas/tests/series/methods/test_convert.py
+++ b/pandas/tests/series/methods/test_convert.py
@@ -108,15 +108,15 @@ def test_convert(self):
         result = ser._convert(datetime=True)
         tm.assert_series_equal(result, expected)
 
-        # preserver if non-object
+        # preserve if non-object
         ser = Series([1], dtype="float32")
         result = ser._convert(datetime=True)
         tm.assert_series_equal(result, ser)
 
         # FIXME: dont leave commented-out
         # res = ser.copy()
-        # r[0] = np.nan
-        # result = res._convert(convert_dates=True,convert_numeric=False)
+        # res[0] = np.nan
+        # result = res._convert(datetime=True, numeric=False)
         # assert result.dtype == 'M8[ns]'
 
     def test_convert_no_arg_error(self):
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 8d18eba36af5e..b7379e0f6eb49 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -244,13 +244,6 @@ def test_add_corner_cases(self, datetime_series):
         result = empty + empty.copy()
         assert len(result) == 0
 
-        # FIXME: dont leave commented-out
-        # TODO: this returned NotImplemented earlier, what to do?
-        # deltas = Series([timedelta(1)] * 5, index=np.arange(5))
-        # sub_deltas = deltas[::2]
-        # deltas5 = deltas * 5
-        # deltas = deltas + sub_deltas
-
     def test_add_float_plus_int(self, datetime_series):
         # float + int
         int_ts = datetime_series.astype(int)[:-5]
@@ -613,11 +606,6 @@ def test_comparison_operators_with_nas(self, comparison_op):
 
         tm.assert_series_equal(result, expected)
 
-        # FIXME: dont leave commented-out
-        # result = comparison_op(val, ser)
-        # expected = comparison_op(val, ser.dropna()).reindex(ser.index)
-        # tm.assert_series_equal(result, expected)
-
     def test_ne(self):
         ts = Series([3, 4, 5, 6, 7], [3, 4, 5, 6, 7], dtype=float)
         expected = [True, True, False, True, True]
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 4867ba58838ef..3842e9a625b8b 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -90,13 +90,13 @@ def test_to_datetime_format(self, cache):
                     tm.assert_index_equal(result, expected)
 
     def test_to_datetime_format_YYYYMMDD(self, cache):
-        s = Series([19801222, 19801222] + [19810105] * 5)
-        expected = Series([Timestamp(x) for x in s.apply(str)])
+        ser = Series([19801222, 19801222] + [19810105] * 5)
+        expected = Series([Timestamp(x) for x in ser.apply(str)])
 
-        result = to_datetime(s, format="%Y%m%d", cache=cache)
+        result = to_datetime(ser, format="%Y%m%d", cache=cache)
         tm.assert_series_equal(result, expected)
 
-        result = to_datetime(s.apply(str), format="%Y%m%d", cache=cache)
+        result = to_datetime(ser.apply(str), format="%Y%m%d", cache=cache)
         tm.assert_series_equal(result, expected)
 
         # with NaT
@@ -104,15 +104,15 @@ def test_to_datetime_format_YYYYMMDD(self, cache):
             [Timestamp("19801222"), Timestamp("19801222")] + [Timestamp("19810105")] * 5
         )
         expected[2] = np.nan
-        s[2] = np.nan
+        ser[2] = np.nan
 
-        result = to_datetime(s, format="%Y%m%d", cache=cache)
+        result = to_datetime(ser, format="%Y%m%d", cache=cache)
         tm.assert_series_equal(result, expected)
 
         # string with NaT
-        s = s.apply(str)
-        s[2] = "nat"
-        result = to_datetime(s, format="%Y%m%d", cache=cache)
+        ser2 = ser.apply(str)
+        ser2[2] = "nat"
+        result = to_datetime(ser2, format="%Y%m%d", cache=cache)
         tm.assert_series_equal(result, expected)
 
     def test_to_datetime_format_YYYYMMDD_coercion(self, cache):
@@ -208,16 +208,16 @@ def test_to_datetime_with_NA(self, data, format, expected):
 
     def test_to_datetime_format_integer(self, cache):
         # GH 10178
-        s = Series([2000, 2001, 2002])
-        expected = Series([Timestamp(x) for x in s.apply(str)])
+        ser = Series([2000, 2001, 2002])
+        expected = Series([Timestamp(x) for x in ser.apply(str)])
 
-        result = to_datetime(s, format="%Y", cache=cache)
+        result = to_datetime(ser, format="%Y", cache=cache)
         tm.assert_series_equal(result, expected)
 
-        s = Series([200001, 200105, 200206])
-        expected = Series([Timestamp(x[:4] + "-" + x[4:]) for x in s.apply(str)])
+        ser = Series([200001, 200105, 200206])
+        expected = Series([Timestamp(x[:4] + "-" + x[4:]) for x in ser.apply(str)])
 
-        result = to_datetime(s, format="%Y%m", cache=cache)
+        result = to_datetime(ser, format="%Y%m", cache=cache)
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -262,29 +262,36 @@ def test_to_datetime_format_time(self, cache):
                 "01/10/2010 13:56:01",
                 "%m/%d/%Y %H:%M:%S",
                 Timestamp("2010-01-10 13:56:01"),
-            ]  # ,
-            # FIXME: don't leave commented-out
-            # ['01/10/2010 08:14 PM', '%m/%d/%Y %I:%M %p',
-            #  Timestamp('2010-01-10 20:14')],
-            # ['01/10/2010 07:40 AM', '%m/%d/%Y %I:%M %p',
-            #  Timestamp('2010-01-10 07:40')],
-            # ['01/10/2010 09:12:56 AM', '%m/%d/%Y %I:%M:%S %p',
-            #  Timestamp('2010-01-10 09:12:56')]
+            ],
+        ]
+        locale_specific = [
+            ["01/10/2010 08:14 PM", "%m/%d/%Y %I:%M %p", Timestamp("2010-01-10 20:14")],
+            ["01/10/2010 07:40 AM", "%m/%d/%Y %I:%M %p", Timestamp("2010-01-10 07:40")],
+            [
+                "01/10/2010 09:12:56 AM",
+                "%m/%d/%Y %I:%M:%S %p",
+                Timestamp("2010-01-10 09:12:56"),
+            ],
         ]
-        for s, format, dt in data:
-            assert to_datetime(s, format=format, cache=cache) == dt
+        if locale.getlocale()[0] == "en_US":
+            # this fail on a CI build with LC_ALL=zh_CN.utf8, so en_US
+            #  may be more specific than necessary.
+            data.extend(locale_specific)
+
+        for value, format, dt in data:
+            assert to_datetime(value, format=format, cache=cache) == dt
 
     @td.skip_if_has_locale
     def test_to_datetime_with_non_exact(self, cache):
         # GH 10834
         # 8904
         # exact kw
-        s = Series(
+        ser = Series(
             ["19MAY11", "foobar19MAY11", "19MAY11:00:00:00", "19MAY11 00:00:00Z"]
         )
-        result = to_datetime(s, format="%d%b%y", exact=False, cache=cache)
+        result = to_datetime(ser, format="%d%b%y", exact=False, cache=cache)
         expected = to_datetime(
-            s.str.extract(r"(\d+\w+\d+)", expand=False), format="%d%b%y", cache=cache
+            ser.str.extract(r"(\d+\w+\d+)", expand=False), format="%d%b%y", cache=cache
         )
         tm.assert_series_equal(result, expected)
 
@@ -543,8 +550,8 @@ def test_to_datetime_YYYYMMDD(self):
 
     def test_to_datetime_unparseable_ignore(self):
         # unparsable
-        s = "Month 1, 1999"
-        assert to_datetime(s, errors="ignore") == s
+        ser = "Month 1, 1999"
+        assert to_datetime(ser, errors="ignore") == ser
 
     @td.skip_if_windows  # `tm.set_timezone` does not work in windows
     def test_to_datetime_now(self):
@@ -1356,8 +1363,8 @@ def test_to_datetime_unit_fractional_seconds(self):
 
         # GH13834
         epoch = 1370745748
-        s = Series([epoch + t for t in np.arange(0, 2, 0.25)] + [iNaT]).astype(float)
-        result = to_datetime(s, unit="s")
+        ser = Series([epoch + t for t in np.arange(0, 2, 0.25)] + [iNaT]).astype(float)
+        result = to_datetime(ser, unit="s")
         expected = Series(
             [
                 Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t)
@@ -1397,13 +1404,6 @@ def test_to_timestamp_unit_coerce(self):
 
 
 class TestToDatetimeDataFrame:
-    @pytest.fixture(params=[True, False])
-    def cache(self, request):
-        """
-        cache keyword to pass to to_datetime.
-        """
-        return request.param
-
     @pytest.fixture
     def df(self):
         return DataFrame(
@@ -1619,30 +1619,35 @@ def test_to_datetime_default(self, cache):
         xp = datetime(2001, 1, 1)
         assert rs == xp
 
+    @pytest.mark.xfail(reason="fails to enforce dayfirst=True, which would raise")
+    def test_to_datetime_respects_dayfirst(self, cache):
         # dayfirst is essentially broken
-        # FIXME: don't leave commented-out
-        # to_datetime('01-13-2012', dayfirst=True)
-        # pytest.raises(ValueError, to_datetime('01-13-2012',
-        #                   dayfirst=True))
+
+        # The msg here is not important since it isn't actually raised yet.
+        msg = "Invalid date specified"
+        with pytest.raises(ValueError, match=msg):
+            # if dayfirst is respected, then this would parse as month=13, which
+            #  would raise
+            to_datetime("01-13-2012", dayfirst=True, cache=cache)
 
     def test_to_datetime_on_datetime64_series(self, cache):
         # #2699
-        s = Series(date_range("1/1/2000", periods=10))
+        ser = Series(date_range("1/1/2000", periods=10))
 
-        result = to_datetime(s, cache=cache)
-        assert result[0] == s[0]
+        result = to_datetime(ser, cache=cache)
+        assert result[0] == ser[0]
 
     def test_to_datetime_with_space_in_series(self, cache):
         # GH 6428
-        s = Series(["10/18/2006", "10/18/2008", " "])
+        ser = Series(["10/18/2006", "10/18/2008", " "])
         msg = r"(\(')?String does not contain a date(:', ' '\))?"
         with pytest.raises(ValueError, match=msg):
-            to_datetime(s, errors="raise", cache=cache)
-        result_coerce = to_datetime(s, errors="coerce", cache=cache)
+            to_datetime(ser, errors="raise", cache=cache)
+        result_coerce = to_datetime(ser, errors="coerce", cache=cache)
         expected_coerce = Series([datetime(2006, 10, 18), datetime(2008, 10, 18), NaT])
         tm.assert_series_equal(result_coerce, expected_coerce)
-        result_ignore = to_datetime(s, errors="ignore", cache=cache)
-        tm.assert_series_equal(result_ignore, s)
+        result_ignore = to_datetime(ser, errors="ignore", cache=cache)
+        tm.assert_series_equal(result_ignore, ser)
 
     @td.skip_if_has_locale
     def test_to_datetime_with_apply(self, cache):
@@ -1681,23 +1686,22 @@ def test_to_datetime_types(self, cache):
         expected = to_datetime(0, cache=cache)
         assert result == expected
 
+    def test_to_datetime_strings(self, cache):
         # GH 3888 (strings)
         expected = to_datetime(["2012"], cache=cache)[0]
         result = to_datetime("2012", cache=cache)
         assert result == expected
 
-        # FIXME: don't leave commented-out
-        # array = ['2012','20120101','20120101 12:01:01']
-        array = ["20120101", "20120101 12:01:01"]
+        array = ["2012", "20120101", "20120101 12:01:01"]
         expected = list(to_datetime(array, cache=cache))
         result = [Timestamp(date_str) for date_str in array]
         tm.assert_almost_equal(result, expected)
 
-        # FIXME: don't leave commented-out
-        # currently fails ###
-        # result = Timestamp('2012')
-        # expected = to_datetime('2012')
-        # assert result == expected
+        expected = Timestamp(2012, 1, 1)
+        result = Timestamp("2012")
+        assert result == expected
+        result = to_datetime("2012")
+        assert result == expected
 
     def test_to_datetime_unprocessable_input(self, cache):
         # GH 4928
@@ -1963,12 +1967,12 @@ def test_guess_datetime_format_for_array(self):
 
 class TestToDatetimeInferFormat:
     def test_to_datetime_infer_datetime_format_consistent_format(self, cache):
-        s = Series(date_range("20000101", periods=50, freq="H"))
+        ser = Series(date_range("20000101", periods=50, freq="H"))
 
         test_formats = ["%m-%d-%Y", "%m/%d/%Y %H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S.%f"]
 
         for test_format in test_formats:
-            s_as_dt_strings = s.apply(lambda x: x.strftime(test_format))
+            s_as_dt_strings = ser.apply(lambda x: x.strftime(test_format))
 
             with_format = to_datetime(s_as_dt_strings, format=test_format, cache=cache)
             no_infer = to_datetime(
@@ -1984,7 +1988,7 @@ def test_to_datetime_infer_datetime_format_consistent_format(self, cache):
             tm.assert_series_equal(no_infer, yes_infer)
 
     def test_to_datetime_infer_datetime_format_inconsistent_format(self, cache):
-        s = Series(
+        ser = Series(
             np.array(
                 ["01/01/2011 00:00:00", "01-02-2011 00:00:00", "2011-01-03T00:00:00"]
             )
@@ -1993,31 +1997,31 @@ def test_to_datetime_infer_datetime_format_inconsistent_format(self, cache):
         # When the format is inconsistent, infer_datetime_format should just
         # fallback to the default parsing
         tm.assert_series_equal(
-            to_datetime(s, infer_datetime_format=False, cache=cache),
-            to_datetime(s, infer_datetime_format=True, cache=cache),
+            to_datetime(ser, infer_datetime_format=False, cache=cache),
+            to_datetime(ser, infer_datetime_format=True, cache=cache),
         )
 
-        s = Series(np.array(["Jan/01/2011", "Feb/01/2011", "Mar/01/2011"]))
+        ser = Series(np.array(["Jan/01/2011", "Feb/01/2011", "Mar/01/2011"]))
 
         tm.assert_series_equal(
-            to_datetime(s, infer_datetime_format=False, cache=cache),
-            to_datetime(s, infer_datetime_format=True, cache=cache),
+            to_datetime(ser, infer_datetime_format=False, cache=cache),
+            to_datetime(ser, infer_datetime_format=True, cache=cache),
         )
 
     def test_to_datetime_infer_datetime_format_series_with_nans(self, cache):
-        s = Series(
+        ser = Series(
             np.array(
                 ["01/01/2011 00:00:00", np.nan, "01/03/2011 00:00:00", np.nan],
                 dtype=object,
             )
         )
         tm.assert_series_equal(
-            to_datetime(s, infer_datetime_format=False, cache=cache),
-            to_datetime(s, infer_datetime_format=True, cache=cache),
+            to_datetime(ser, infer_datetime_format=False, cache=cache),
+            to_datetime(ser, infer_datetime_format=True, cache=cache),
         )
 
     def test_to_datetime_infer_datetime_format_series_start_with_nans(self, cache):
-        s = Series(
+        ser = Series(
             np.array(
                 [
                     np.nan,
@@ -2031,8 +2035,8 @@ def test_to_datetime_infer_datetime_format_series_start_with_nans(self, cache):
         )
 
         tm.assert_series_equal(
-            to_datetime(s, infer_datetime_format=False, cache=cache),
-            to_datetime(s, infer_datetime_format=True, cache=cache),
+            to_datetime(ser, infer_datetime_format=False, cache=cache),
+            to_datetime(ser, infer_datetime_format=True, cache=cache),
         )
 
     @pytest.mark.parametrize(
@@ -2040,8 +2044,8 @@ def test_to_datetime_infer_datetime_format_series_start_with_nans(self, cache):
     )
     def test_infer_datetime_format_tz_name(self, tz_name, offset):
         # GH 33133
-        s = Series([f"2019-02-02 08:07:13 {tz_name}"])
-        result = to_datetime(s, infer_datetime_format=True)
+        ser = Series([f"2019-02-02 08:07:13 {tz_name}"])
+        result = to_datetime(ser, infer_datetime_format=True)
         expected = Series(
             [Timestamp("2019-02-02 08:07:13").tz_localize(pytz.FixedOffset(offset))]
         )
@@ -2058,15 +2062,15 @@ def test_infer_datetime_format_tz_name(self, tz_name, offset):
     )
     def test_infer_datetime_format_zero_tz(self, ts, zero_tz, is_utc):
         # GH 41047
-        s = Series([ts + zero_tz])
-        result = to_datetime(s, infer_datetime_format=True)
+        ser = Series([ts + zero_tz])
+        result = to_datetime(ser, infer_datetime_format=True)
         tz = pytz.utc if is_utc else None
         expected = Series([Timestamp(ts, tz=tz)])
         tm.assert_series_equal(result, expected)
 
     def test_to_datetime_iso8601_noleading_0s(self, cache):
         # GH 11871
-        s = Series(["2014-1-1", "2014-2-2", "2015-3-3"])
+        ser = Series(["2014-1-1", "2014-2-2", "2015-3-3"])
         expected = Series(
             [
                 Timestamp("2014-01-01"),
@@ -2074,8 +2078,10 @@ def test_to_datetime_iso8601_noleading_0s(self, cache):
                 Timestamp("2015-03-03"),
             ]
         )
-        tm.assert_series_equal(to_datetime(s, cache=cache), expected)
-        tm.assert_series_equal(to_datetime(s, format="%Y-%m-%d", cache=cache), expected)
+        tm.assert_series_equal(to_datetime(ser, cache=cache), expected)
+        tm.assert_series_equal(
+            to_datetime(ser, format="%Y-%m-%d", cache=cache), expected
+        )
 
 
 class TestDaysInMonth: