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):