TST: parametrize tests over dt64 unit

pandas/tests/indexes/datetimes/test_date_range.py

@@ -473,6 +473,12 @@ def test_date_range_businesshour(self):
         rng = date_range("2014-07-04 09:00", "2014-07-08 16:00", freq="bh")
         tm.assert_index_equal(idx, rng)
 
+    def test_date_range_business_hour_short(self, unit):
+        # GH#49835
+        idx4 = date_range(start="2014-07-01 10:00", freq="bh", periods=1, unit=unit)
+        expected4 = DatetimeIndex(["2014-07-01 10:00"], freq="bh").as_unit(unit)
+        tm.assert_index_equal(idx4, expected4)
+
     def test_date_range_timedelta(self):
         start = "2020-01-01"
         end = "2020-01-11"

pandas/tests/indexes/interval/test_interval.py

@@ -86,7 +86,11 @@ def test_properties(self, closed):
         [
             [1, 1, 2, 5, 15, 53, 217, 1014, 5335, 31240, 201608],
             [-np.inf, -100, -10, 0.5, 1, 1.5, 3.8, 101, 202, np.inf],
-            pd.to_datetime(["20170101", "20170202", "20170303", "20170404"]),
+            date_range("2017-01-01", "2017-01-04"),
+            pytest.param(
+                date_range("2017-01-01", "2017-01-04", unit="s"),
+                marks=pytest.mark.xfail(reason="mismatched result unit"),
+            ),
             pd.to_timedelta(["1ns", "2ms", "3s", "4min", "5h", "6D"]),
         ],
     )

pandas/tests/reductions/test_reductions.py

@@ -822,24 +822,23 @@ def test_numpy_argmax(self):
         # See GH#16830
         data = np.arange(1, 11)
 
-        s = Series(data, index=data)
-        result = np.argmax(s)
+        ser = Series(data, index=data)
+        result = np.argmax(ser)
         expected = np.argmax(data)
         assert result == expected
 
-        result = s.argmax()
+        result = ser.argmax()
 
         assert result == expected
 
         msg = "the 'out' parameter is not supported"
         with pytest.raises(ValueError, match=msg):
-            np.argmax(s, out=data)
+            np.argmax(ser, out=data)
 
-    def test_idxmin_dt64index(self):
+    def test_idxmin_dt64index(self, unit):
         # GH#43587 should have NaT instead of NaN
-        ser = Series(
-            [1.0, 2.0, np.nan], index=DatetimeIndex(["NaT", "2015-02-08", "NaT"])
-        )
+        dti = DatetimeIndex(["NaT", "2015-02-08", "NaT"]).as_unit(unit)
+        ser = Series([1.0, 2.0, np.nan], index=dti)
         msg = "The behavior of Series.idxmin with all-NA values"
         with tm.assert_produces_warning(FutureWarning, match=msg):
             res = ser.idxmin(skipna=False)
@@ -853,12 +852,12 @@ def test_idxmin_dt64index(self):
         msg = "The behavior of DataFrame.idxmin with all-NA values"
         with tm.assert_produces_warning(FutureWarning, match=msg):
             res = df.idxmin(skipna=False)
-        assert res.dtype == "M8[ns]"
+        assert res.dtype == f"M8[{unit}]"
         assert res.isna().all()
         msg = "The behavior of DataFrame.idxmax with all-NA values"
         with tm.assert_produces_warning(FutureWarning, match=msg):
             res = df.idxmax(skipna=False)
-        assert res.dtype == "M8[ns]"
+        assert res.dtype == f"M8[{unit}]"
         assert res.isna().all()
 
     def test_idxmin(self):

pandas/tests/resample/test_datetime_index.py

@@ -1357,15 +1357,16 @@ def test_resample_consistency(unit):
 
 
 @pytest.mark.parametrize("dates", [dates1, dates2, dates3])
-def test_resample_timegrouper(dates):
+def test_resample_timegrouper(dates, unit):
     # GH 7227
+    dates = DatetimeIndex(dates).as_unit(unit)
     df = DataFrame({"A": dates, "B": np.arange(len(dates))})
     result = df.set_index("A").resample("ME").count()
     exp_idx = DatetimeIndex(
         ["2014-07-31", "2014-08-31", "2014-09-30", "2014-10-31", "2014-11-30"],
         freq="ME",
         name="A",
-    )
+    ).as_unit(unit)
     expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx)
     if df["A"].isna().any():
         expected.index = expected.index._with_freq(None)
@@ -2039,26 +2040,39 @@ def test_resample_BM_deprecated():
     tm.assert_series_equal(result, expected)
 
 
-def test_resample_ms_closed_right():
+def test_resample_ms_closed_right(unit):
     # https://github.com/pandas-dev/pandas/issues/55271
-    dti = date_range(start="2020-01-31", freq="1min", periods=6000)
+    dti = date_range(start="2020-01-31", freq="1min", periods=6000, unit=unit)
     df = DataFrame({"ts": dti}, index=dti)
     grouped = df.resample("MS", closed="right")
     result = grouped.last()
+    exp_dti = DatetimeIndex(
+        [datetime(2020, 1, 1), datetime(2020, 2, 1)], freq="MS"
+    ).as_unit(unit)
     expected = DataFrame(
         {"ts": [datetime(2020, 2, 1), datetime(2020, 2, 4, 3, 59)]},
-        index=DatetimeIndex([datetime(2020, 1, 1), datetime(2020, 2, 1)], freq="MS"),
-    )
+        index=exp_dti,
+    ).astype(f"M8[{unit}]")
     tm.assert_frame_equal(result, expected)
 
 
 @pytest.mark.parametrize("freq", ["B", "C"])
-def test_resample_c_b_closed_right(freq: str):
+def test_resample_c_b_closed_right(freq: str, unit):
     # https://github.com/pandas-dev/pandas/issues/55281
-    dti = date_range(start="2020-01-31", freq="1min", periods=6000)
+    dti = date_range(start="2020-01-31", freq="1min", periods=6000, unit=unit)
     df = DataFrame({"ts": dti}, index=dti)
     grouped = df.resample(freq, closed="right")
     result = grouped.last()
+
+    exp_dti = DatetimeIndex(
+        [
+            datetime(2020, 1, 30),
+            datetime(2020, 1, 31),
+            datetime(2020, 2, 3),
+            datetime(2020, 2, 4),
+        ],
+        freq=freq,
+    ).as_unit(unit)
     expected = DataFrame(
         {
             "ts": [
@@ -2068,35 +2082,28 @@ def test_resample_c_b_closed_right(freq: str):
                 datetime(2020, 2, 4, 3, 59),
             ]
         },
-        index=DatetimeIndex(
-            [
-                datetime(2020, 1, 30),
-                datetime(2020, 1, 31),
-                datetime(2020, 2, 3),
-                datetime(2020, 2, 4),
-            ],
-            freq=freq,
-        ),
-    )
+        index=exp_dti,
+    ).astype(f"M8[{unit}]")
     tm.assert_frame_equal(result, expected)
 
 
-def test_resample_b_55282():
+def test_resample_b_55282(unit):
     # https://github.com/pandas-dev/pandas/issues/55282
-    s = Series(
-        [1, 2, 3, 4, 5, 6], index=date_range("2023-09-26", periods=6, freq="12h")
-    )
-    result = s.resample("B", closed="right", label="right").mean()
+    dti = date_range("2023-09-26", periods=6, freq="12h", unit=unit)
+    ser = Series([1, 2, 3, 4, 5, 6], index=dti)
+    result = ser.resample("B", closed="right", label="right").mean()
+
+    exp_dti = DatetimeIndex(
+        [
+            datetime(2023, 9, 26),
+            datetime(2023, 9, 27),
+            datetime(2023, 9, 28),
+            datetime(2023, 9, 29),
+        ],
+        freq="B",
+    ).as_unit(unit)
     expected = Series(
         [1.0, 2.5, 4.5, 6.0],
-        index=DatetimeIndex(
-            [
-                datetime(2023, 9, 26),
-                datetime(2023, 9, 27),
-                datetime(2023, 9, 28),
-                datetime(2023, 9, 29),
-            ],
-            freq="B",
-        ),
+        index=exp_dti,
     )
     tm.assert_series_equal(result, expected)

pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -309,13 +309,13 @@ def test_td_add_sub_td64_ndarray(self):
 
     def test_td_add_sub_dt64_ndarray(self):
         td = Timedelta("1 day")
-        other = pd.to_datetime(["2000-01-01"]).values
+        other = np.array(["2000-01-01"], dtype="M8[ns]")
 
-        expected = pd.to_datetime(["2000-01-02"]).values
+        expected = np.array(["2000-01-02"], dtype="M8[ns]")
         tm.assert_numpy_array_equal(td + other, expected)
         tm.assert_numpy_array_equal(other + td, expected)
 
-        expected = pd.to_datetime(["1999-12-31"]).values
+        expected = np.array(["1999-12-31"], dtype="M8[ns]")
         tm.assert_numpy_array_equal(-td + other, expected)
         tm.assert_numpy_array_equal(other - td, expected)
 

pandas/tests/series/methods/test_map.py

@@ -418,38 +418,44 @@ def __missing__(self, key):
     tm.assert_series_equal(result, expected)
 
 
-def test_map_box():
+def test_map_box_dt64(unit):
     vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
-    s = Series(vals)
-    assert s.dtype == "datetime64[ns]"
+    ser = Series(vals).dt.as_unit(unit)
+    assert ser.dtype == f"datetime64[{unit}]"
     # boxed value must be Timestamp instance
-    res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
+    res = ser.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
     exp = Series(["Timestamp_1_None", "Timestamp_2_None"])
     tm.assert_series_equal(res, exp)
 
+
+def test_map_box_dt64tz(unit):
     vals = [
         pd.Timestamp("2011-01-01", tz="US/Eastern"),
         pd.Timestamp("2011-01-02", tz="US/Eastern"),
     ]
-    s = Series(vals)
-    assert s.dtype == "datetime64[ns, US/Eastern]"
-    res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
+    ser = Series(vals).dt.as_unit(unit)
+    assert ser.dtype == f"datetime64[{unit}, US/Eastern]"
+    res = ser.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
     exp = Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"])
     tm.assert_series_equal(res, exp)
 
+
+def test_map_box_td64(unit):
     # timedelta
     vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")]
-    s = Series(vals)
-    assert s.dtype == "timedelta64[ns]"
-    res = s.map(lambda x: f"{type(x).__name__}_{x.days}")
+    ser = Series(vals).dt.as_unit(unit)
+    assert ser.dtype == f"timedelta64[{unit}]"
+    res = ser.map(lambda x: f"{type(x).__name__}_{x.days}")
     exp = Series(["Timedelta_1", "Timedelta_2"])
     tm.assert_series_equal(res, exp)
 
+
+def test_map_box_period():
     # period
     vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
-    s = Series(vals)
-    assert s.dtype == "Period[M]"
-    res = s.map(lambda x: f"{type(x).__name__}_{x.freqstr}")
+    ser = Series(vals)
+    assert ser.dtype == "Period[M]"
+    res = ser.map(lambda x: f"{type(x).__name__}_{x.freqstr}")
     exp = Series(["Period_M", "Period_M"])
     tm.assert_series_equal(res, exp)
 

pandas/tests/series/methods/test_quantile.py

@@ -48,7 +48,8 @@ def test_quantile(self, datetime_series):
         with pytest.raises(ValueError, match=msg):
             s.quantile(percentile_array)
 
-    def test_quantile_multi(self, datetime_series):
+    def test_quantile_multi(self, datetime_series, unit):
+        datetime_series.index = datetime_series.index.as_unit(unit)
         qs = [0.1, 0.9]
         result = datetime_series.quantile(qs)
         expected = Series(
@@ -68,6 +69,7 @@ def test_quantile_multi(self, datetime_series):
             [Timestamp("2000-01-10 19:12:00"), Timestamp("2000-01-10 19:12:00")],
             index=[0.2, 0.2],
             name="xxx",
+            dtype=f"M8[{unit}]",
         )
         tm.assert_series_equal(result, expected)
 

pandas/tests/series/methods/test_tz_localize.py

@@ -70,11 +70,11 @@ def test_series_tz_localize_matching_index(self):
             ["foo", "invalid"],
         ],
     )
-    def test_tz_localize_nonexistent(self, warsaw, method, exp):
+    def test_tz_localize_nonexistent(self, warsaw, method, exp, unit):
         # GH 8917
         tz = warsaw
         n = 60
-        dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min")
+        dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min", unit=unit)
         ser = Series(1, index=dti)
         df = ser.to_frame()
 
@@ -101,7 +101,7 @@ def test_tz_localize_nonexistent(self, warsaw, method, exp):
 
         else:
             result = ser.tz_localize(tz, nonexistent=method)
-            expected = Series(1, index=DatetimeIndex([exp] * n, tz=tz))
+            expected = Series(1, index=DatetimeIndex([exp] * n, tz=tz).as_unit(unit))
             tm.assert_series_equal(result, expected)
 
             result = df.tz_localize(tz, nonexistent=method)

pandas/tests/series/methods/test_value_counts.py

@@ -12,7 +12,7 @@
 
 
 class TestSeriesValueCounts:
-    def test_value_counts_datetime(self):
+    def test_value_counts_datetime(self, unit):
         # most dtypes are tested in tests/base
         values = [
             pd.Timestamp("2011-01-01 09:00"),
@@ -26,21 +26,21 @@ def test_value_counts_datetime(self):
         exp_idx = pd.DatetimeIndex(
             ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
             name="xxx",
-        )
+        ).as_unit(unit)
         exp = Series([3, 2, 1], index=exp_idx, name="count")
 
-        ser = Series(values, name="xxx")
+        ser = Series(values, name="xxx").dt.as_unit(unit)
         tm.assert_series_equal(ser.value_counts(), exp)
         # check DatetimeIndex outputs the same result
-        idx = pd.DatetimeIndex(values, name="xxx")
+        idx = pd.DatetimeIndex(values, name="xxx").as_unit(unit)
         tm.assert_series_equal(idx.value_counts(), exp)
 
         # normalize
         exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
         tm.assert_series_equal(ser.value_counts(normalize=True), exp)
         tm.assert_series_equal(idx.value_counts(normalize=True), exp)
 
-    def test_value_counts_datetime_tz(self):
+    def test_value_counts_datetime_tz(self, unit):
         values = [
             pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
             pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"),
@@ -54,12 +54,12 @@ def test_value_counts_datetime_tz(self):
             ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
             tz="US/Eastern",
             name="xxx",
-        )
+        ).as_unit(unit)
         exp = Series([3, 2, 1], index=exp_idx, name="count")
 
-        ser = Series(values, name="xxx")
+        ser = Series(values, name="xxx").dt.as_unit(unit)
         tm.assert_series_equal(ser.value_counts(), exp)
-        idx = pd.DatetimeIndex(values, name="xxx")
+        idx = pd.DatetimeIndex(values, name="xxx").as_unit(unit)
         tm.assert_series_equal(idx.value_counts(), exp)
 
         exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")

pandas/tests/series/test_arithmetic.py

@@ -749,13 +749,17 @@ def test_series_add_aware_naive_raises(self):
         with pytest.raises(Exception, match=msg):
             ser_utc + ser
 
-    def test_datetime_understood(self):
+    # TODO: belongs in tests/arithmetic?
+    def test_datetime_understood(self, unit):
         # Ensures it doesn't fail to create the right series
         # reported in issue#16726
-        series = Series(date_range("2012-01-01", periods=3))
+        series = Series(date_range("2012-01-01", periods=3, unit=unit))
         offset = pd.offsets.DateOffset(days=6)
         result = series - offset
-        expected = Series(pd.to_datetime(["2011-12-26", "2011-12-27", "2011-12-28"]))
+        exp_dti = pd.to_datetime(["2011-12-26", "2011-12-27", "2011-12-28"]).as_unit(
+            unit
+        )
+        expected = Series(exp_dti)
         tm.assert_series_equal(result, expected)
 
     def test_align_date_objects_with_datetimeindex(self):

pandas/tests/test_algos.py

@@ -757,23 +757,6 @@ def test_order_of_appearance(self):
         result = pd.unique(Series([2] + [1] * 5))
         tm.assert_numpy_array_equal(result, np.array([2, 1], dtype="int64"))
 
-        result = pd.unique(Series([Timestamp("20160101"), Timestamp("20160101")]))
-        expected = np.array(["2016-01-01T00:00:00.000000000"], dtype="datetime64[ns]")
-        tm.assert_numpy_array_equal(result, expected)
-
-        result = pd.unique(
-            Index(
-                [
-                    Timestamp("20160101", tz="US/Eastern"),
-                    Timestamp("20160101", tz="US/Eastern"),
-                ]
-            )
-        )
-        expected = DatetimeIndex(
-            ["2016-01-01 00:00:00"], dtype="datetime64[ns, US/Eastern]", freq=None
-        )
-        tm.assert_index_equal(result, expected)
-
         msg = "unique with argument that is not not a Series, Index,"
         with tm.assert_produces_warning(FutureWarning, match=msg):
             result = pd.unique(list("aabc"))
@@ -784,6 +767,25 @@ def test_order_of_appearance(self):
         expected = Categorical(list("abc"))
         tm.assert_categorical_equal(result, expected)
 
+    def test_order_of_appearance_dt64(self, unit):
+        ser = Series([Timestamp("20160101"), Timestamp("20160101")]).dt.as_unit(unit)
+        result = pd.unique(ser)
+        expected = np.array(["2016-01-01T00:00:00.000000000"], dtype=f"M8[{unit}]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_order_of_appearance_dt64tz(self, unit):
+        dti = DatetimeIndex(
+            [
+                Timestamp("20160101", tz="US/Eastern"),
+                Timestamp("20160101", tz="US/Eastern"),
+            ]
+        ).as_unit(unit)
+        result = pd.unique(dti)
+        expected = DatetimeIndex(
+            ["2016-01-01 00:00:00"], dtype=f"datetime64[{unit}, US/Eastern]", freq=None
+        )
+        tm.assert_index_equal(result, expected)
+
     @pytest.mark.parametrize(
         "arg ,expected",
         [

pandas/tests/tseries/holiday/test_calendar.py

@@ -57,8 +57,11 @@ def __init__(self, name=None, rules=None) -> None:
     jan2 = TestCalendar(rules=[Holiday("jan2", year=2015, month=1, day=2)])
 
     # Getting holidays for Jan 1 should not alter results for Jan 2.
-    tm.assert_index_equal(jan1.holidays(), DatetimeIndex(["01-Jan-2015"]))
-    tm.assert_index_equal(jan2.holidays(), DatetimeIndex(["02-Jan-2015"]))
+    expected = DatetimeIndex(["01-Jan-2015"]).as_unit("ns")
+    tm.assert_index_equal(jan1.holidays(), expected)
+
+    expected2 = DatetimeIndex(["02-Jan-2015"]).as_unit("ns")
+    tm.assert_index_equal(jan2.holidays(), expected2)
 
 
 def test_calendar_observance_dates():

pandas/tests/tseries/holiday/test_holiday.py

@@ -327,5 +327,6 @@ def test_holidays_with_timezone_specified_but_no_occurences():
         start_date, end_date, return_name=True
     )
     expected_results = Series("New Year's Day", index=[start_date])
+    expected_results.index = expected_results.index.as_unit("ns")
 
     tm.assert_equal(test_case, expected_results)

pandas/tests/tseries/offsets/test_business_hour.py

@@ -978,12 +978,6 @@ def test_datetimeindex(self):
         for idx in [idx1, idx2, idx3]:
             tm.assert_index_equal(idx, expected)
 
-    def test_short_datetimeindex_creation(self):
-        # gh-49835
-        idx4 = date_range(start="2014-07-01 10:00", freq="bh", periods=1)
-        expected4 = DatetimeIndex(["2014-07-01 10:00"], freq="bh")
-        tm.assert_index_equal(idx4, expected4)
-
     @pytest.mark.parametrize("td_unit", ["s", "ms", "us", "ns"])
     @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
     def test_bday_ignores_timedeltas(self, unit, td_unit):

pandas/tests/window/test_rolling.py

@@ -977,20 +977,23 @@ def scaled_sum(*args):
 
 
 @pytest.mark.parametrize("add", [0.0, 2.0])
-def test_rolling_numerical_accuracy_kahan_mean(add):
+def test_rolling_numerical_accuracy_kahan_mean(add, unit):
     # GH: 36031 implementing kahan summation
-    df = DataFrame(
-        {"A": [3002399751580331.0 + add, -0.0, -0.0]},
-        index=[
+    dti = DatetimeIndex(
+        [
             Timestamp("19700101 09:00:00"),
             Timestamp("19700101 09:00:03"),
             Timestamp("19700101 09:00:06"),
-        ],
+        ]
+    ).as_unit(unit)
+    df = DataFrame(
+        {"A": [3002399751580331.0 + add, -0.0, -0.0]},
+        index=dti,
     )
     result = (
         df.resample("1s").ffill().rolling("3s", closed="left", min_periods=3).mean()
     )
-    dates = date_range("19700101 09:00:00", periods=7, freq="s")
+    dates = date_range("19700101 09:00:00", periods=7, freq="s", unit=unit)
     expected = DataFrame(
         {
             "A": [
@@ -1196,8 +1199,19 @@ def test_rolling_var_numerical_issues(func, third_value, values):
     tm.assert_series_equal(result == 0, expected == 0)
 
 
-def test_timeoffset_as_window_parameter_for_corr():
+def test_timeoffset_as_window_parameter_for_corr(unit):
     # GH: 28266
+    dti = DatetimeIndex(
+        [
+            Timestamp("20130101 09:00:00"),
+            Timestamp("20130102 09:00:02"),
+            Timestamp("20130103 09:00:03"),
+            Timestamp("20130105 09:00:05"),
+            Timestamp("20130106 09:00:06"),
+        ]
+    ).as_unit(unit)
+    mi = MultiIndex.from_product([dti, ["B", "A"]])
+
     exp = DataFrame(
         {
             "B": [
@@ -1225,31 +1239,12 @@ def test_timeoffset_as_window_parameter_for_corr():
                 1.0000000000000002,
             ],
         },
-        index=MultiIndex.from_tuples(
-            [
-                (Timestamp("20130101 09:00:00"), "B"),
-                (Timestamp("20130101 09:00:00"), "A"),
-                (Timestamp("20130102 09:00:02"), "B"),
-                (Timestamp("20130102 09:00:02"), "A"),
-                (Timestamp("20130103 09:00:03"), "B"),
-                (Timestamp("20130103 09:00:03"), "A"),
-                (Timestamp("20130105 09:00:05"), "B"),
-                (Timestamp("20130105 09:00:05"), "A"),
-                (Timestamp("20130106 09:00:06"), "B"),
-                (Timestamp("20130106 09:00:06"), "A"),
-            ]
-        ),
+        index=mi,
     )
 
     df = DataFrame(
         {"B": [0, 1, 2, 4, 3], "A": [7, 4, 6, 9, 3]},
-        index=[
-            Timestamp("20130101 09:00:00"),
-            Timestamp("20130102 09:00:02"),
-            Timestamp("20130103 09:00:03"),
-            Timestamp("20130105 09:00:05"),
-            Timestamp("20130106 09:00:06"),
-        ],
+        index=dti,
     )
 
     res = df.rolling(window="3d").corr()

pandas/tests/window/test_timeseries_window.py

@@ -3,7 +3,7 @@
 
 from pandas import (
     DataFrame,
-    Index,
+    DatetimeIndex,
     MultiIndex,
     NaT,
     Series,
@@ -178,21 +178,22 @@ def test_frame_on(self):
         result = df.rolling("2s", on="A")[["B"]].sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_frame_on2(self):
+    def test_frame_on2(self, unit):
         # using multiple aggregation columns
+        dti = DatetimeIndex(
+            [
+                Timestamp("20130101 09:00:00"),
+                Timestamp("20130101 09:00:02"),
+                Timestamp("20130101 09:00:03"),
+                Timestamp("20130101 09:00:05"),
+                Timestamp("20130101 09:00:06"),
+            ]
+        ).as_unit(unit)
         df = DataFrame(
             {
                 "A": [0, 1, 2, 3, 4],
                 "B": [0, 1, 2, np.nan, 4],
-                "C": Index(
-                    [
-                        Timestamp("20130101 09:00:00"),
-                        Timestamp("20130101 09:00:02"),
-                        Timestamp("20130101 09:00:03"),
-                        Timestamp("20130101 09:00:05"),
-                        Timestamp("20130101 09:00:06"),
-                    ]
-                ),
+                "C": dti,
             },
             columns=["A", "C", "B"],
         )
@@ -248,18 +249,22 @@ def test_min_periods(self, regular):
         result = df.rolling("2s", min_periods=1).sum()
         tm.assert_frame_equal(result, expected)
 
-    def test_closed(self, regular):
+    def test_closed(self, regular, unit):
         # xref GH13965
 
-        df = DataFrame(
-            {"A": [1] * 5},
-            index=[
+        dti = DatetimeIndex(
+            [
                 Timestamp("20130101 09:00:01"),
                 Timestamp("20130101 09:00:02"),
                 Timestamp("20130101 09:00:03"),
                 Timestamp("20130101 09:00:04"),
                 Timestamp("20130101 09:00:06"),
-            ],
+            ]
+        ).as_unit(unit)
+
+        df = DataFrame(
+            {"A": [1] * 5},
+            index=dti,
         )
 
         # closed must be 'right', 'left', 'both', 'neither'
@@ -642,15 +647,17 @@ def test_rolling_cov_offset(self):
         expected2 = ss.rolling(3, min_periods=1).cov()
         tm.assert_series_equal(result, expected2)
 
-    def test_rolling_on_decreasing_index(self):
+    def test_rolling_on_decreasing_index(self, unit):
         # GH-19248, GH-32385
-        index = [
-            Timestamp("20190101 09:00:30"),
-            Timestamp("20190101 09:00:27"),
-            Timestamp("20190101 09:00:20"),
-            Timestamp("20190101 09:00:18"),
-            Timestamp("20190101 09:00:10"),
-        ]
+        index = DatetimeIndex(
+            [
+                Timestamp("20190101 09:00:30"),
+                Timestamp("20190101 09:00:27"),
+                Timestamp("20190101 09:00:20"),
+                Timestamp("20190101 09:00:18"),
+                Timestamp("20190101 09:00:10"),
+            ]
+        ).as_unit(unit)
 
         df = DataFrame({"column": [3, 4, 4, 5, 6]}, index=index)
         result = df.rolling("5s").min()