diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 4b198af88dec9..735660e5ae688 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -745,6 +745,7 @@ Other API changes
   the dtype of the resulting Index (:issue:`60797`)
 - :class:`IncompatibleFrequency` now subclasses ``TypeError`` instead of ``ValueError``. As a result, joins with mismatched frequencies now cast to object like other non-comparable joins, and arithmetic with indexes with mismatched frequencies align (:issue:`55782`)
 - :class:`Series` "flex" methods like :meth:`Series.add` no longer allow passing a :class:`DataFrame` for ``other``; use the DataFrame reversed method instead (:issue:`46179`)
+- :func:`date_range` and :func:`timedelta_range` no longer default to ``unit="ns"``, instead will infer a unit from the ``start``, ``end``, and ``freq`` parameters. Explicitly specify a desired ``unit`` to override these (:issue:`59031`)
 - :meth:`CategoricalIndex.append` no longer attempts to cast different-dtype indexes to the caller's dtype (:issue:`41626`)
 - :meth:`ExtensionDtype.construct_array_type` is now a regular method instead of a ``classmethod`` (:issue:`58663`)
 - Comparison operations between :class:`Index` and :class:`Series` now consistently return :class:`Series` regardless of which object is on the left or right (:issue:`36759`)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 6aace23bf6da0..770dbba531c3b 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1649,7 +1649,7 @@ def mean(self, *, skipna: bool = True, axis: AxisInt | None = 0):
         >>> idx = pd.date_range("2001-01-01 00:00", periods=3)
         >>> idx
         DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
         >>> idx.mean()
         Timestamp('2001-01-02 00:00:00')
 
@@ -1900,13 +1900,13 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
     >>> rng
     DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
                    '2018-01-01 12:01:00'],
-                  dtype='datetime64[ns]', freq='min')
+                  dtype='datetime64[us]', freq='min')
     """
 
 _round_example = """>>> rng.round('h')
     DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
                    '2018-01-01 12:00:00'],
-                  dtype='datetime64[ns]', freq=None)
+                  dtype='datetime64[us]', freq=None)
 
     **Series**
 
@@ -1914,7 +1914,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
     0   2018-01-01 12:00:00
     1   2018-01-01 12:00:00
     2   2018-01-01 12:00:00
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
 
     When rounding near a daylight savings time transition, use ``ambiguous`` or
     ``nonexistent`` to control how the timestamp should be re-localized.
@@ -1933,7 +1933,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
 _floor_example = """>>> rng.floor('h')
     DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
                    '2018-01-01 12:00:00'],
-                  dtype='datetime64[ns]', freq=None)
+                  dtype='datetime64[us]', freq=None)
 
     **Series**
 
@@ -1941,7 +1941,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
     0   2018-01-01 11:00:00
     1   2018-01-01 12:00:00
     2   2018-01-01 12:00:00
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
 
     When rounding near a daylight savings time transition, use ``ambiguous`` or
     ``nonexistent`` to control how the timestamp should be re-localized.
@@ -1960,7 +1960,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
 _ceil_example = """>>> rng.ceil('h')
     DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
                    '2018-01-01 13:00:00'],
-                  dtype='datetime64[ns]', freq=None)
+                  dtype='datetime64[us]', freq=None)
 
     **Series**
 
@@ -1968,7 +1968,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
     0   2018-01-01 12:00:00
     1   2018-01-01 12:00:00
     2   2018-01-01 13:00:00
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
 
     When rounding near a daylight savings time transition, use ``ambiguous`` or
     ``nonexistent`` to control how the timestamp should be re-localized.
@@ -2018,7 +2018,7 @@ def freq(self):
                        '2022-02-22 06:22:22-06:00', '2022-02-22 07:22:22-06:00',
                        '2022-02-22 08:22:22-06:00', '2022-02-22 09:22:22-06:00',
                        '2022-02-22 10:22:22-06:00', '2022-02-22 11:22:22-06:00'],
-                      dtype='datetime64[ns, America/Chicago]', freq='h')
+                      dtype='datetime64[us, America/Chicago]', freq='h')
         >>> datetimeindex.freq
         <Hour>
         """
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 08ac11106e2df..d5fa14866857b 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -912,13 +912,13 @@ def tz_convert(self, tz) -> Self:
         DatetimeIndex(['2014-08-01 09:00:00+02:00',
                        '2014-08-01 10:00:00+02:00',
                        '2014-08-01 11:00:00+02:00'],
-                        dtype='datetime64[ns, Europe/Berlin]', freq='h')
+                        dtype='datetime64[us, Europe/Berlin]', freq='h')
 
         >>> dti.tz_convert(None)
         DatetimeIndex(['2014-08-01 07:00:00',
                        '2014-08-01 08:00:00',
                        '2014-08-01 09:00:00'],
-                        dtype='datetime64[ns]', freq='h')
+                        dtype='datetime64[us]', freq='h')
         """  # noqa: E501
         tz = timezones.maybe_get_tz(tz)
 
@@ -1009,7 +1009,7 @@ def tz_localize(
         >>> tz_naive
         DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00',
                        '2018-03-03 09:00:00'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
 
         Localize DatetimeIndex in US/Eastern time zone:
 
@@ -1018,7 +1018,7 @@ def tz_localize(
         DatetimeIndex(['2018-03-01 09:00:00-05:00',
                        '2018-03-02 09:00:00-05:00',
                        '2018-03-03 09:00:00-05:00'],
-                      dtype='datetime64[ns, US/Eastern]', freq=None)
+                      dtype='datetime64[us, US/Eastern]', freq=None)
 
         With the ``tz=None``, we can remove the time zone information
         while keeping the local time (not converted to UTC):
@@ -1026,7 +1026,7 @@ def tz_localize(
         >>> tz_aware.tz_localize(None)
         DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00',
                        '2018-03-03 09:00:00'],
-                      dtype='datetime64[ns]', freq=None)
+                      dtype='datetime64[us]', freq=None)
 
         Be careful with DST changes. When there is sequential data, pandas can
         infer the DST time:
@@ -1179,12 +1179,12 @@ def normalize(self) -> Self:
         DatetimeIndex(['2014-08-01 10:00:00+05:30',
                        '2014-08-01 11:00:00+05:30',
                        '2014-08-01 12:00:00+05:30'],
-                        dtype='datetime64[ns, Asia/Calcutta]', freq='h')
+                        dtype='datetime64[us, Asia/Calcutta]', freq='h')
         >>> idx.normalize()
         DatetimeIndex(['2014-08-01 00:00:00+05:30',
                        '2014-08-01 00:00:00+05:30',
                        '2014-08-01 00:00:00+05:30'],
-                       dtype='datetime64[ns, Asia/Calcutta]', freq=None)
+                       dtype='datetime64[us, Asia/Calcutta]', freq=None)
         """
         new_values = normalize_i8_timestamps(self.asi8, self.tz, reso=self._creso)
         dt64_values = new_values.view(self._ndarray.dtype)
@@ -1308,7 +1308,7 @@ def month_name(self, locale=None) -> npt.NDArray[np.object_]:
         0   2018-01-31
         1   2018-02-28
         2   2018-03-31
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> s.dt.month_name()
         0     January
         1    February
@@ -1318,7 +1318,7 @@ def month_name(self, locale=None) -> npt.NDArray[np.object_]:
         >>> idx = pd.date_range(start="2018-01", freq="ME", periods=3)
         >>> idx
         DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
-                      dtype='datetime64[ns]', freq='ME')
+                      dtype='datetime64[us]', freq='ME')
         >>> idx.month_name()
         Index(['January', 'February', 'March'], dtype='str')
 
@@ -1329,7 +1329,7 @@ def month_name(self, locale=None) -> npt.NDArray[np.object_]:
         >>> idx = pd.date_range(start="2018-01", freq="ME", periods=3)
         >>> idx
         DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
-                      dtype='datetime64[ns]', freq='ME')
+                      dtype='datetime64[us]', freq='ME')
         >>> idx.month_name(locale="pt_BR.utf8")  # doctest: +SKIP
         Index(['Janeiro', 'Fevereiro', 'Março'], dtype='str')
         """
@@ -1376,7 +1376,7 @@ def day_name(self, locale=None) -> npt.NDArray[np.object_]:
         0   2018-01-01
         1   2018-01-02
         2   2018-01-03
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> s.dt.day_name()
         0       Monday
         1      Tuesday
@@ -1386,7 +1386,7 @@ def day_name(self, locale=None) -> npt.NDArray[np.object_]:
         >>> idx = pd.date_range(start="2018-01-01", freq="D", periods=3)
         >>> idx
         DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
         >>> idx.day_name()
         Index(['Monday', 'Tuesday', 'Wednesday'], dtype='str')
 
@@ -1397,7 +1397,7 @@ def day_name(self, locale=None) -> npt.NDArray[np.object_]:
         >>> idx = pd.date_range(start="2018-01-01", freq="D", periods=3)
         >>> idx
         DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
         >>> idx.day_name(locale="pt_BR.utf8")  # doctest: +SKIP
         Index(['Segunda', 'Terça', 'Quarta'], dtype='str')
         """
@@ -1610,7 +1610,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-12-31
         1   2001-12-31
         2   2002-12-31
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.year
         0    2000
         1    2001
@@ -1638,7 +1638,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-31
         1   2000-02-29
         2   2000-03-31
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.month
         0    1
         1    2
@@ -1667,7 +1667,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-01
         1   2000-01-02
         2   2000-01-03
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.day
         0    1
         1    2
@@ -1696,7 +1696,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-01 00:00:00
         1   2000-01-01 01:00:00
         2   2000-01-01 02:00:00
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.hour
         0    0
         1    1
@@ -1724,7 +1724,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-01 00:00:00
         1   2000-01-01 00:01:00
         2   2000-01-01 00:02:00
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.minute
         0    0
         1    1
@@ -1753,7 +1753,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-01 00:00:00
         1   2000-01-01 00:00:01
         2   2000-01-01 00:00:02
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.second
         0    0
         1    1
@@ -1781,7 +1781,7 @@ def isocalendar(self) -> DataFrame:
         0   2000-01-01 00:00:00.000000
         1   2000-01-01 00:00:00.000001
         2   2000-01-01 00:00:00.000002
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> datetime_series.dt.microsecond
         0       0
         1       1
@@ -1981,7 +1981,7 @@ def isocalendar(self) -> DataFrame:
         0   2018-02-27
         1   2018-02-28
         2   2018-03-01
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> s.dt.is_month_start
         0    False
         1    False
@@ -2043,7 +2043,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range('2017-03-30', periods=4)
         >>> idx
         DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
 
         >>> idx.is_quarter_start
         array([False, False,  True, False])
@@ -2085,7 +2085,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range('2017-03-30', periods=4)
         >>> idx
         DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
 
         >>> idx.is_quarter_end
         array([False,  True, False, False])
@@ -2118,7 +2118,7 @@ def isocalendar(self) -> DataFrame:
         0   2017-12-30
         1   2017-12-31
         2   2018-01-01
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
 
         >>> dates.dt.is_year_start
         0    False
@@ -2129,7 +2129,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range("2017-12-30", periods=3)
         >>> idx
         DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
 
         >>> idx.is_year_start
         array([False, False,  True])
@@ -2143,7 +2143,7 @@ def isocalendar(self) -> DataFrame:
         1   2022-01-03
         2   2023-01-02
         3   2024-01-01
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
 
         >>> dates.dt.is_year_start
         0    True
@@ -2155,7 +2155,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range("2020-10-30", periods=4, freq="BYS")
         >>> idx
         DatetimeIndex(['2021-01-01', '2022-01-03', '2023-01-02', '2024-01-01'],
-                      dtype='datetime64[ns]', freq='BYS-JAN')
+                      dtype='datetime64[us]', freq='BYS-JAN')
 
         >>> idx.is_year_start
         array([ True,  True,  True,  True])
@@ -2188,7 +2188,7 @@ def isocalendar(self) -> DataFrame:
         0   2017-12-30
         1   2017-12-31
         2   2018-01-01
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
 
         >>> dates.dt.is_year_end
         0    False
@@ -2199,7 +2199,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range("2017-12-30", periods=3)
         >>> idx
         DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
 
         >>> idx.is_year_end
         array([False,  True, False])
@@ -2236,7 +2236,7 @@ def isocalendar(self) -> DataFrame:
         >>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="YE")
         >>> idx
         DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'],
-                      dtype='datetime64[ns]', freq='YE-DEC')
+                      dtype='datetime64[us]', freq='YE-DEC')
         >>> idx.is_leap_year
         array([ True, False, False])
 
@@ -2245,7 +2245,7 @@ def isocalendar(self) -> DataFrame:
         0   2012-12-31
         1   2013-12-31
         2   2014-12-31
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         >>> dates_series.dt.is_leap_year
         0     True
         1    False
@@ -2379,7 +2379,7 @@ def std(
         >>> idx = pd.date_range("2001-01-01 00:00", periods=3)
         >>> idx
         DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
-                      dtype='datetime64[ns]', freq='D')
+                      dtype='datetime64[us]', freq='D')
         >>> idx.std()
         Timedelta('1 days 00:00:00')
         """
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 940231233e308..fa246bd27db8f 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6446,7 +6446,7 @@ def astype(
         0   2020-01-01
         1   2020-01-02
         2   2020-01-03
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
         """
         self._check_copy_deprecation(copy)
         if is_dict_like(dtype):
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index b9a0af6b0bc28..d748c6fa1b7dc 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -286,7 +286,7 @@ class DatetimeProperties(Properties):
     0   2000-01-01 00:00:00
     1   2000-01-01 00:00:01
     2   2000-01-01 00:00:02
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
     >>> seconds_series.dt.second
     0    0
     1    1
@@ -298,7 +298,7 @@ class DatetimeProperties(Properties):
     0   2000-01-01 00:00:00
     1   2000-01-01 01:00:00
     2   2000-01-01 02:00:00
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
     >>> hours_series.dt.hour
     0    0
     1    1
@@ -310,7 +310,7 @@ class DatetimeProperties(Properties):
     0   2000-03-31
     1   2000-06-30
     2   2000-09-30
-    dtype: datetime64[ns]
+    dtype: datetime64[us]
     >>> quarters_series.dt.quarter
     0    1
     1    2
@@ -347,7 +347,7 @@ def to_pydatetime(self) -> Series:
         >>> s
         0   2018-03-10
         1   2018-03-11
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
 
         >>> s.dt.to_pydatetime()
         0    2018-03-10 00:00:00
@@ -360,7 +360,7 @@ def to_pydatetime(self) -> Series:
         >>> s
         0   2018-03-10 00:00:00.000000000
         1   2018-03-10 00:00:00.000000001
-        dtype: datetime64[ns]
+        dtype: datetime64[us]
 
         >>> s.dt.to_pydatetime()
         0    2018-03-10 00:00:00
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index d26a9313865cd..ecbe383fa3fb1 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -25,7 +25,11 @@
     timezones,
     to_offset,
 )
-from pandas._libs.tslibs.offsets import prefix_mapping
+from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
+from pandas._libs.tslibs.offsets import (
+    DateOffset,
+    prefix_mapping,
+)
 from pandas.errors import Pandas4Warning
 from pandas.util._decorators import (
     cache_readonly,
@@ -841,7 +845,7 @@ def indexer_between_time(
         >>> idx
         DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00',
                            '2023-01-01 02:00:00', '2023-01-01 03:00:00'],
-                          dtype='datetime64[ns]', freq='h')
+                          dtype='datetime64[us]', freq='h')
         >>> idx.indexer_between_time("00:00", "2:00", include_end=False)
         array([0, 1])
         """
@@ -883,7 +887,7 @@ def date_range(
     name: Hashable | None = None,
     inclusive: IntervalClosedType = "both",
     *,
-    unit: TimeUnit = "ns",
+    unit: TimeUnit | None = None,
     **kwargs,
 ) -> DatetimeIndex:
     """
@@ -922,8 +926,9 @@ def date_range(
         Name of the resulting DatetimeIndex.
     inclusive : {"both", "neither", "left", "right"}, default "both"
         Include boundaries; Whether to set each bound as closed or open.
-    unit : {'s', 'ms', 'us', 'ns'}, default 'ns'
+    unit : {'s', 'ms', 'us', 'ns', None}, default None
         Specify the desired resolution of the result.
+        If not specified, this is inferred from the 'start', 'end', and 'freq'
 
         .. versionadded:: 2.0.0
     **kwargs
@@ -965,7 +970,7 @@ def date_range(
     >>> pd.date_range(start="1/1/2018", end="1/08/2018")
     DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                    '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     Specify timezone-aware `start` and `end`, with the default daily frequency.
 
@@ -977,21 +982,21 @@ def date_range(
                    '2018-01-03 00:00:00+01:00', '2018-01-04 00:00:00+01:00',
                    '2018-01-05 00:00:00+01:00', '2018-01-06 00:00:00+01:00',
                    '2018-01-07 00:00:00+01:00', '2018-01-08 00:00:00+01:00'],
-                  dtype='datetime64[ns, Europe/Berlin]', freq='D')
+                  dtype='datetime64[us, Europe/Berlin]', freq='D')
 
     Specify `start` and `periods`, the number of periods (days).
 
     >>> pd.date_range(start="1/1/2018", periods=8)
     DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                    '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     Specify `end` and `periods`, the number of periods (days).
 
     >>> pd.date_range(end="1/1/2018", periods=8)
     DatetimeIndex(['2017-12-25', '2017-12-26', '2017-12-27', '2017-12-28',
                    '2017-12-29', '2017-12-30', '2017-12-31', '2018-01-01'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     Specify `start`, `end`, and `periods`; the frequency is generated
     automatically (linearly spaced).
@@ -999,7 +1004,7 @@ def date_range(
     >>> pd.date_range(start="2018-04-24", end="2018-04-27", periods=3)
     DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00',
                    '2018-04-27 00:00:00'],
-                  dtype='datetime64[ns]', freq=None)
+                  dtype='datetime64[us]', freq=None)
 
     **Other Parameters**
 
@@ -1008,21 +1013,21 @@ def date_range(
     >>> pd.date_range(start="1/1/2018", periods=5, freq="ME")
     DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
                    '2018-05-31'],
-                  dtype='datetime64[ns]', freq='ME')
+                  dtype='datetime64[us]', freq='ME')
 
     Multiples are allowed
 
     >>> pd.date_range(start="1/1/2018", periods=5, freq="3ME")
     DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                    '2019-01-31'],
-                  dtype='datetime64[ns]', freq='3ME')
+                  dtype='datetime64[us]', freq='3ME')
 
     `freq` can also be specified as an Offset object.
 
     >>> pd.date_range(start="1/1/2018", periods=5, freq=pd.offsets.MonthEnd(3))
     DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                    '2019-01-31'],
-                  dtype='datetime64[ns]', freq='3ME')
+                  dtype='datetime64[us]', freq='3ME')
 
     Specify `tz` to set the timezone.
 
@@ -1030,27 +1035,27 @@ def date_range(
     DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
                    '2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
                    '2018-01-05 00:00:00+09:00'],
-                  dtype='datetime64[ns, Asia/Tokyo]', freq='D')
+                  dtype='datetime64[us, Asia/Tokyo]', freq='D')
 
     `inclusive` controls whether to include `start` and `end` that are on the
     boundary. The default, "both", includes boundary points on either end.
 
     >>> pd.date_range(start="2017-01-01", end="2017-01-04", inclusive="both")
     DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     Use ``inclusive='left'`` to exclude `end` if it falls on the boundary.
 
     >>> pd.date_range(start="2017-01-01", end="2017-01-04", inclusive="left")
     DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     Use ``inclusive='right'`` to exclude `start` if it falls on the boundary, and
     similarly ``inclusive='neither'`` will exclude both `start` and `end`.
 
     >>> pd.date_range(start="2017-01-01", end="2017-01-04", inclusive="right")
     DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
-                  dtype='datetime64[ns]', freq='D')
+                  dtype='datetime64[us]', freq='D')
 
     **Specify a unit**
 
@@ -1062,6 +1067,50 @@ def date_range(
     """
     if freq is None and com.any_none(periods, start, end):
         freq = "D"
+    if freq is not None:
+        freq = to_offset(freq)
+
+    if start is NaT or end is NaT:
+        # This check needs to come before the `unit = start.unit` line below
+        raise ValueError("Neither `start` nor `end` can be NaT")
+
+    if unit is None:
+        # Infer the unit based on the inputs
+
+        if start is not None and end is not None:
+            start = Timestamp(start)
+            end = Timestamp(end)
+            if abbrev_to_npy_unit(start.unit) > abbrev_to_npy_unit(end.unit):
+                unit = start.unit
+            else:
+                unit = end.unit
+        elif start is not None:
+            start = Timestamp(start)
+            unit = start.unit
+        elif end is not None:
+            end = Timestamp(end)
+            unit = end.unit
+        else:
+            raise ValueError(
+                "Of the four parameters: start, end, periods, "
+                "and freq, exactly three must be specified"
+            )
+
+        # Last we need to watch out for cases where the 'freq' implies a higher
+        #  unit than either start or end
+        if freq is not None:
+            creso = abbrev_to_npy_unit(unit)
+            if isinstance(freq, Tick):
+                if freq._creso > creso:
+                    unit = freq.base.freqstr  # type: ignore[assignment]
+            elif hasattr(freq, "offset") and freq.offset is not None:
+                # e.g. BDay with an offset
+                td = Timedelta(freq.offset)
+                if abbrev_to_npy_unit(td.unit) > creso:
+                    unit = td.unit  # type: ignore[assignment]
+            elif type(freq) is DateOffset and getattr(freq, "nanoseconds", 0) != 0:
+                # e.g. test_freq_dateoffset_with_relateivedelta_nanos
+                unit = "ns"
 
     dtarr = DatetimeArray._generate_range(
         start=start,
@@ -1153,7 +1202,7 @@ def bdate_range(
     >>> pd.bdate_range(start="1/1/2018", end="1/08/2018")
     DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                '2018-01-05', '2018-01-08'],
-              dtype='datetime64[ns]', freq='B')
+              dtype='datetime64[us]', freq='B')
     """
     if freq is None:
         msg = "freq must be specified for bdate_range; use date_range instead"
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 37b1838665ee9..7bb64503a469e 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -1339,7 +1339,7 @@ def interval_range(
     IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00],
                    (2017-01-02 00:00:00, 2017-01-03 00:00:00],
                    (2017-01-03 00:00:00, 2017-01-04 00:00:00]],
-                  dtype='interval[datetime64[ns], right]')
+                  dtype='interval[datetime64[us], right]')
 
     The ``freq`` parameter specifies the frequency between the left and right.
     endpoints of the individual intervals within the ``IntervalIndex``.  For
@@ -1356,7 +1356,7 @@ def interval_range(
     IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00],
                    (2017-02-01 00:00:00, 2017-03-01 00:00:00],
                    (2017-03-01 00:00:00, 2017-04-01 00:00:00]],
-                  dtype='interval[datetime64[ns], right]')
+                  dtype='interval[datetime64[us], right]')
 
     Specify ``start``, ``end``, and ``periods``; the frequency is generated
     automatically (linearly spaced).
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index be8d1e465ed34..ce9fd52e9aad8 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
 
 from pandas._libs import (
     index as libindex,
@@ -13,6 +16,7 @@
     Timedelta,
     to_offset,
 )
+from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
 from pandas.util._decorators import set_module
 
 from pandas.core.dtypes.common import (
@@ -33,6 +37,10 @@
 
 if TYPE_CHECKING:
     from pandas._libs import NaTType
+    from pandas._libs.tslibs import (
+        Day,
+        Tick,
+    )
     from pandas._typing import (
         DtypeObj,
         TimeUnit,
@@ -252,7 +260,7 @@ def timedelta_range(
     name=None,
     closed=None,
     *,
-    unit: TimeUnit = "ns",
+    unit: TimeUnit | None = None,
 ) -> TimedeltaIndex:
     """
     Return a fixed frequency TimedeltaIndex with day as the default.
@@ -272,8 +280,9 @@ def timedelta_range(
     closed : str, default None
         Make the interval closed with respect to the given frequency to
         the 'left', 'right', or both sides (None).
-    unit : {'s', 'ms', 'us', 'ns'}, default 'ns'
+    unit : {'s', 'ms', 'us', 'ns', None}, default None
         Specify the desired resolution of the result.
+        If not specified, this is inferred from the 'start', 'end', and 'freq'
 
         .. versionadded:: 2.0.0
 
@@ -337,8 +346,44 @@ def timedelta_range(
     """
     if freq is None and com.any_none(periods, start, end):
         freq = "D"
-
     freq = to_offset(freq)
+
+    if com.count_not_none(start, end, periods, freq) != 3:
+        # This check needs to come before the `unit = start.unit` line below
+        raise ValueError(
+            "Of the four parameters: start, end, periods, "
+            "and freq, exactly three must be specified"
+        )
+
+    if unit is None:
+        # Infer the unit based on the inputs
+
+        if start is not None and end is not None:
+            start = Timedelta(start)
+            end = Timedelta(end)
+            start = cast(Timedelta, start)
+            end = cast(Timedelta, end)
+            if abbrev_to_npy_unit(start.unit) > abbrev_to_npy_unit(end.unit):
+                unit = cast("TimeUnit", start.unit)
+            else:
+                unit = cast("TimeUnit", end.unit)
+        elif start is not None:
+            start = Timedelta(start)
+            start = cast(Timedelta, start)
+            unit = cast("TimeUnit", start.unit)
+        else:
+            end = Timedelta(end)
+            end = cast(Timedelta, end)
+            unit = cast("TimeUnit", end.unit)
+
+        # Last we need to watch out for cases where the 'freq' implies a higher
+        #  unit than either start or end
+        if freq is not None:
+            freq = cast("Tick | Day", freq)
+            creso = abbrev_to_npy_unit(unit)
+            if freq._creso > creso:  # pyright: ignore[reportAttributeAccessIssue]
+                unit = cast("TimeUnit", freq.base.freqstr)
+
     tdarr = TimedeltaArray._generate_range(
         start, end, periods, freq, closed=closed, unit=unit
     )
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 6d7e713b7ad6b..392025f447365 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -777,7 +777,7 @@ def values(self):
         >>> pd.Series(pd.date_range("20130101", periods=3, tz="US/Eastern")).values
         array(['2013-01-01T05:00:00.000000000',
                '2013-01-02T05:00:00.000000000',
-               '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')
+               '2013-01-03T05:00:00.000000000'], dtype='datetime64[us]')
         """
         return self._mgr.external_values()
 
diff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py
index 06793769b39bb..71ce9f9a618bc 100644
--- a/pandas/tests/apply/test_frame_apply.py
+++ b/pandas/tests/apply/test_frame_apply.py
@@ -653,13 +653,15 @@ def test_apply_dict(df, dicts):
 
 def test_apply_non_numpy_dtype():
     # GH 12244
-    df = DataFrame({"dt": date_range("2015-01-01", periods=3, tz="Europe/Brussels")})
+    df = DataFrame(
+        {"dt": date_range("2015-01-01", periods=3, tz="Europe/Brussels", unit="ns")}
+    )
     result = df.apply(lambda x: x)
     tm.assert_frame_equal(result, df)
 
     result = df.apply(lambda x: x + pd.Timedelta("1day"))
     expected = DataFrame(
-        {"dt": date_range("2015-01-02", periods=3, tz="Europe/Brussels")}
+        {"dt": date_range("2015-01-02", periods=3, tz="Europe/Brussels", unit="ns")}
     )
     tm.assert_frame_equal(result, expected)
 
@@ -1425,7 +1427,7 @@ def test_nuiscance_columns():
             "A": [1, 2, 3],
             "B": [1.0, 2.0, 3.0],
             "C": ["foo", "bar", "baz"],
-            "D": date_range("20130101", periods=3),
+            "D": date_range("20130101", periods=3, unit="ns"),
         }
     )
 
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index b83dc3052fbb3..7fd5db3a6e83e 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -589,7 +589,7 @@ def test_comparison_tzawareness_compat(self, comparison_op, box_with_array):
         op = comparison_op
         box = box_with_array
 
-        dr = date_range("2016-01-01", periods=6)
+        dr = date_range("2016-01-01", periods=6, unit="ns")
         dz = dr.tz_localize("US/Pacific")
 
         dr = tm.box_expected(dr, box)
@@ -637,7 +637,7 @@ def test_comparison_tzawareness_compat_scalars(self, comparison_op, box_with_arr
         # GH#18162
         op = comparison_op
 
-        dr = date_range("2016-01-01", periods=6)
+        dr = date_range("2016-01-01", periods=6, unit="ns")
         dz = dr.tz_localize("US/Pacific")
 
         dr = tm.box_expected(dr, box_with_array)
@@ -676,7 +676,7 @@ def test_scalar_comparison_tzawareness(
     ):
         op = comparison_op
         tz = tz_aware_fixture
-        dti = date_range("2016-01-01", periods=2, tz=tz)
+        dti = date_range("2016-01-01", periods=2, tz=tz, unit="ns")
 
         dtarr = tm.box_expected(dti, box_with_array)
         xbox = get_upcast_box(dtarr, other, True)
@@ -833,8 +833,8 @@ def test_dt64arr_add_timedeltalike_scalar(
         # GH#22005, GH#22163 check DataFrame doesn't raise TypeError
         tz = tz_naive_fixture
 
-        rng = date_range("2000-01-01", "2000-02-01", tz=tz)
-        expected = date_range("2000-01-01 02:00", "2000-02-01 02:00", tz=tz)
+        rng = date_range("2000-01-01", "2000-02-01", tz=tz, unit="ns")
+        expected = date_range("2000-01-01 02:00", "2000-02-01 02:00", tz=tz, unit="ns")
         if tz is not None:
             expected = expected._with_freq(None)
 
@@ -855,8 +855,8 @@ def test_dt64arr_sub_timedeltalike_scalar(
     ):
         tz = tz_naive_fixture
 
-        rng = date_range("2000-01-01", "2000-02-01", tz=tz)
-        expected = date_range("1999-12-31 22:00", "2000-01-31 22:00", tz=tz)
+        rng = date_range("2000-01-01", "2000-02-01", tz=tz, unit="ns")
+        expected = date_range("1999-12-31 22:00", "2000-01-31 22:00", tz=tz, unit="ns")
         if tz is not None:
             expected = expected._with_freq(None)
 
@@ -870,7 +870,7 @@ def test_dt64arr_sub_timedeltalike_scalar(
         tm.assert_equal(rng, expected)
 
     def test_dt64_array_sub_dt_with_different_timezone(self, box_with_array):
-        t1 = date_range("20130101", periods=3).tz_localize("US/Eastern")
+        t1 = date_range("20130101", periods=3, unit="ns").tz_localize("US/Eastern")
         t1 = tm.box_expected(t1, box_with_array)
         t2 = Timestamp("20130101").tz_localize("CET")
         tnaive = Timestamp(20130101)
@@ -897,11 +897,11 @@ def test_dt64_array_sub_dt_with_different_timezone(self, box_with_array):
             tnaive - t1
 
     def test_dt64_array_sub_dt64_array_with_different_timezone(self, box_with_array):
-        t1 = date_range("20130101", periods=3).tz_localize("US/Eastern")
+        t1 = date_range("20130101", periods=3, unit="ns").tz_localize("US/Eastern")
         t1 = tm.box_expected(t1, box_with_array)
-        t2 = date_range("20130101", periods=3).tz_localize("CET")
+        t2 = date_range("20130101", periods=3, unit="ns").tz_localize("CET")
         t2 = tm.box_expected(t2, box_with_array)
-        tnaive = date_range("20130101", periods=3)
+        tnaive = date_range("20130101", periods=3, unit="ns")
 
         result = t1 - t2
         expected = TimedeltaIndex(
@@ -928,7 +928,7 @@ def test_dt64arr_add_sub_td64_nat(self, box_with_array, tz_naive_fixture):
         # GH#23320 special handling for timedelta64("NaT")
         tz = tz_naive_fixture
 
-        dti = date_range("1994-04-01", periods=9, tz=tz, freq="QS")
+        dti = date_range("1994-04-01", periods=9, tz=tz, freq="QS", unit="ns")
         other = np.timedelta64("NaT")
         expected = DatetimeIndex(["NaT"] * 9, tz=tz).as_unit("ns")
 
@@ -947,11 +947,11 @@ def test_dt64arr_add_sub_td64_nat(self, box_with_array, tz_naive_fixture):
 
     def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array):
         tz = tz_naive_fixture
-        dti = date_range("2016-01-01", periods=3, tz=tz)
+        dti = date_range("2016-01-01", periods=3, tz=tz, unit="ns")
         tdi = TimedeltaIndex(["-1 Day", "-1 Day", "-1 Day"])
         tdarr = tdi.values
 
-        expected = date_range("2015-12-31", "2016-01-02", periods=3, tz=tz)
+        expected = date_range("2015-12-31", "2016-01-02", periods=3, tz=tz, unit="ns")
 
         dtarr = tm.box_expected(dti, box_with_array)
         expected = tm.box_expected(expected, box_with_array)
@@ -961,7 +961,7 @@ def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array):
         result = tdarr + dtarr
         tm.assert_equal(result, expected)
 
-        expected = date_range("2016-01-02", "2016-01-04", periods=3, tz=tz)
+        expected = date_range("2016-01-02", "2016-01-04", periods=3, tz=tz, unit="ns")
         expected = tm.box_expected(expected, box_with_array)
 
         result = dtarr - tdarr
@@ -991,7 +991,7 @@ def test_dt64arr_add_sub_td64ndarray(self, tz_naive_fixture, box_with_array):
     )
     def test_dt64arr_sub_dtscalar(self, box_with_array, ts):
         # GH#8554, GH#22163 DataFrame op should _not_ return dt64 dtype
-        idx = date_range("2013-01-01", periods=3)._with_freq(None)
+        idx = date_range("2013-01-01", periods=3, unit="ns")._with_freq(None)
         idx = tm.box_expected(idx, box_with_array)
 
         expected = TimedeltaIndex(["0 Days", "1 Day", "2 Days"])
@@ -1005,7 +1005,7 @@ def test_dt64arr_sub_dtscalar(self, box_with_array, ts):
         tm.assert_equal(result, -expected)
 
     def test_dt64arr_sub_timestamp_tzaware(self, box_with_array):
-        ser = date_range("2014-03-17", periods=2, freq="D", tz="US/Eastern")
+        ser = date_range("2014-03-17", periods=2, freq="D", tz="US/Eastern", unit="ns")
         ser = ser._with_freq(None)
         ts = ser[0]
 
@@ -1312,11 +1312,11 @@ def test_dti_add_tick_tzaware(self, tz_aware_fixture, box_with_array):
         # GH#21610, GH#22163 ensure DataFrame doesn't return object-dtype
         tz = tz_aware_fixture
         if tz == "US/Pacific":
-            dates = date_range("2012-11-01", periods=3, tz=tz)
+            dates = date_range("2012-11-01", periods=3, tz=tz, unit="ns")
             offset = dates + pd.offsets.Hour(5)
             assert dates[0] + pd.offsets.Hour(5) == offset[0]
 
-        dates = date_range("2010-11-01 00:00", periods=3, tz=tz, freq="h")
+        dates = date_range("2010-11-01 00:00", periods=3, tz=tz, freq="h", unit="ns")
         expected = DatetimeIndex(
             ["2010-11-01 05:00", "2010-11-01 06:00", "2010-11-01 07:00"],
             freq="h",
@@ -1604,7 +1604,9 @@ def test_dti_add_sub_nonzero_mth_offset(
     ):
         # GH 26258
         tz = tz_aware_fixture
-        date = date_range(start="01 Jan 2014", end="01 Jan 2017", freq="YS", tz=tz)
+        date = date_range(
+            start="01 Jan 2014", end="01 Jan 2017", freq="YS", tz=tz, unit="ns"
+        )
         date = tm.box_expected(date, box_with_array, False)
         mth = getattr(date, op)
         result = mth(offset)
@@ -1667,7 +1669,7 @@ def test_dt64_series_arith_overflow(self):
         # GH#12534, fixed by GH#19024
         dt = Timestamp("1700-01-31")
         td = Timedelta("20000 Days")
-        dti = date_range("1949-09-30", freq="100YE", periods=4)
+        dti = date_range("1949-09-30", freq="100YE", periods=4, unit="ns")
         ser = Series(dti)
         msg = "Overflow in int64 addition"
         with pytest.raises(OverflowError, match=msg):
@@ -1890,7 +1892,7 @@ def test_sub_single_tz(self, unit):
     def test_dt64tz_series_sub_dtitz(self):
         # GH#19071 subtracting tzaware DatetimeIndex from tzaware Series
         # (with same tz) raises, fixed by #19024
-        dti = date_range("1999-09-30", periods=10, tz="US/Pacific")
+        dti = date_range("1999-09-30", periods=10, tz="US/Pacific", unit="ns")
         ser = Series(dti)
         expected = Series(TimedeltaIndex(["0days"] * 10))
 
@@ -2040,7 +2042,7 @@ def test_dti_add_tdi(self, tz_naive_fixture):
         tz = tz_naive_fixture
         dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
         tdi = pd.timedelta_range("0 days", periods=10)
-        expected = date_range("2017-01-01", periods=10, tz=tz)
+        expected = date_range("2017-01-01", periods=10, tz=tz, unit="ns")
         expected = expected._with_freq(None)
 
         # add with TimedeltaIndex
@@ -2062,7 +2064,7 @@ def test_dti_iadd_tdi(self, tz_naive_fixture):
         tz = tz_naive_fixture
         dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
         tdi = pd.timedelta_range("0 days", periods=10)
-        expected = date_range("2017-01-01", periods=10, tz=tz)
+        expected = date_range("2017-01-01", periods=10, tz=tz, unit="ns")
         expected = expected._with_freq(None)
 
         # iadd with TimedeltaIndex
@@ -2088,7 +2090,7 @@ def test_dti_sub_tdi(self, tz_naive_fixture):
         tz = tz_naive_fixture
         dti = DatetimeIndex([Timestamp("2017-01-01", tz=tz)] * 10)
         tdi = pd.timedelta_range("0 days", periods=10)
-        expected = date_range("2017-01-01", periods=10, tz=tz, freq="-1D")
+        expected = date_range("2017-01-01", periods=10, tz=tz, freq="-1D", unit="ns")
         expected = expected._with_freq(None)
 
         # sub with TimedeltaIndex
diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py
index 9a54386abf281..a17a07d15a18f 100644
--- a/pandas/tests/arithmetic/test_timedelta64.py
+++ b/pandas/tests/arithmetic/test_timedelta64.py
@@ -308,7 +308,7 @@ def test_ufunc_coercions(self):
     def test_subtraction_ops(self):
         # with datetimes/timedelta and tdi/dti
         tdi = TimedeltaIndex(["1 days", NaT, "2 days"], name="foo")
-        dti = pd.date_range("20130101", periods=3, name="bar")
+        dti = pd.date_range("20130101", periods=3, name="bar", unit="ns")
         td = Timedelta("1 days")
         dt = Timestamp("20130101")
 
@@ -356,11 +356,13 @@ def test_subtraction_ops(self):
 
     def test_subtraction_ops_with_tz(self, box_with_array):
         # check that dt/dti subtraction ops with tz are validated
-        dti = pd.date_range("20130101", periods=3)
+        dti = pd.date_range("20130101", periods=3, unit="ns")
         dti = tm.box_expected(dti, box_with_array)
         ts = Timestamp("20130101")
         dt = ts.to_pydatetime()
-        dti_tz = pd.date_range("20130101", periods=3).tz_localize("US/Eastern")
+        dti_tz = pd.date_range("20130101", periods=3, unit="ns").tz_localize(
+            "US/Eastern"
+        )
         dti_tz = tm.box_expected(dti_tz, box_with_array)
         ts_tz = Timestamp("20130101").tz_localize("US/Eastern")
         ts_tz2 = Timestamp("20130101").tz_localize("CET")
@@ -520,7 +522,7 @@ def test_addition_ops(self):
     # more targeted tests
     @pytest.mark.parametrize("freq", ["D", "B"])
     def test_timedelta(self, freq):
-        index = pd.date_range("1/1/2000", periods=50, freq=freq)
+        index = pd.date_range("1/1/2000", periods=50, freq=freq, unit="ns")
 
         shifted = index + timedelta(1)
         back = shifted + timedelta(-1)
@@ -842,8 +844,8 @@ def test_timedelta_ops_with_missing_values(self):
     # de-duplication, box-parametrization...
     def test_operators_timedelta64(self):
         # series ops
-        v1 = pd.date_range("2012-1-1", periods=3, freq="D")
-        v2 = pd.date_range("2012-1-2", periods=3, freq="D")
+        v1 = pd.date_range("2012-1-1", periods=3, freq="D", unit="ns")
+        v2 = pd.date_range("2012-1-2", periods=3, freq="D", unit="ns")
         rs = Series(v2) - Series(v1)
         xp = Series(1e9 * 3600 * 24, rs.index).astype("int64").astype("timedelta64[ns]")
         tm.assert_series_equal(rs, xp)
@@ -1011,7 +1013,7 @@ def test_td64arr_add_sub_datetimelike_scalar(
             ts = dt_scalar
 
         tdi = timedelta_range("1 day", periods=3)
-        expected = pd.date_range("2012-01-02", periods=3, tz=tz)
+        expected = pd.date_range("2012-01-02", periods=3, tz=tz, unit="ns")
         if tz is not None and not timezones.is_utc(expected.tz):
             # Day is no longer preserved by timedelta add/sub in pandas3 because
             #  it represents Calendar-Day instead of 24h
@@ -1023,7 +1025,7 @@ def test_td64arr_add_sub_datetimelike_scalar(
         tm.assert_equal(ts + tdarr, expected)
         tm.assert_equal(tdarr + ts, expected)
 
-        expected2 = pd.date_range("2011-12-31", periods=3, freq="-1D", tz=tz)
+        expected2 = pd.date_range("2011-12-31", periods=3, freq="-1D", tz=tz, unit="ns")
         if tz is not None and not timezones.is_utc(expected2.tz):
             # Day is no longer preserved by timedelta add/sub in pandas3 because
             #  it represents Calendar-Day instead of 24h
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index ebbfbfd96d48d..e5b94fe25cff3 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -160,7 +160,7 @@ def test_categorical_repr_ordered(self):
         assert repr(c) == exp
 
     def test_categorical_repr_datetime(self):
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, unit="ns")
         c = Categorical(idx)
 
         exp = (
@@ -188,7 +188,9 @@ def test_categorical_repr_datetime(self):
 
         assert repr(c) == exp
 
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        idx = date_range(
+            "2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern", unit="ns"
+        )
         c = Categorical(idx)
         exp = (
             "[2011-01-01 09:00:00-05:00, 2011-01-01 10:00:00-05:00, "
@@ -222,7 +224,7 @@ def test_categorical_repr_datetime(self):
         assert repr(c) == exp
 
     def test_categorical_repr_datetime_ordered(self):
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, unit="ns")
         c = Categorical(idx, ordered=True)
         exp = """[2011-01-01 09:00:00, 2011-01-01 10:00:00, 2011-01-01 11:00:00, 2011-01-01 12:00:00, 2011-01-01 13:00:00]
 Categories (5, datetime64[ns]): [2011-01-01 09:00:00 < 2011-01-01 10:00:00 < 2011-01-01 11:00:00 <
@@ -237,7 +239,9 @@ def test_categorical_repr_datetime_ordered(self):
 
         assert repr(c) == exp
 
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        idx = date_range(
+            "2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern", unit="ns"
+        )
         c = Categorical(idx, ordered=True)
         exp = """[2011-01-01 09:00:00-05:00, 2011-01-01 10:00:00-05:00, 2011-01-01 11:00:00-05:00, 2011-01-01 12:00:00-05:00, 2011-01-01 13:00:00-05:00]
 Categories (5, datetime64[ns, US/Eastern]): [2011-01-01 09:00:00-05:00 < 2011-01-01 10:00:00-05:00 <
diff --git a/pandas/tests/arrays/datetimes/test_constructors.py b/pandas/tests/arrays/datetimes/test_constructors.py
index 74cc3e991bb76..cfab5588f79a0 100644
--- a/pandas/tests/arrays/datetimes/test_constructors.py
+++ b/pandas/tests/arrays/datetimes/test_constructors.py
@@ -47,7 +47,7 @@ def test_from_pandas_array(self):
 
         result = DatetimeArray._from_sequence(arr, dtype="M8[ns]")._with_freq("infer")
 
-        expected = pd.date_range("1970-01-01", periods=5, freq="h")._data
+        expected = pd.date_range("1970-01-01", periods=5, freq="h", unit="ns")._data
         tm.assert_datetime_array_equal(result, expected)
 
     def test_bool_dtype_raises(self):
diff --git a/pandas/tests/arrays/datetimes/test_reductions.py b/pandas/tests/arrays/datetimes/test_reductions.py
index a58b0f57bf0da..74f7d8f50459f 100644
--- a/pandas/tests/arrays/datetimes/test_reductions.py
+++ b/pandas/tests/arrays/datetimes/test_reductions.py
@@ -143,7 +143,7 @@ def test_mean(self, arr1d):
         assert result == expected
 
     def test_mean_2d(self):
-        dti = pd.date_range("2016-01-01", periods=6, tz="US/Pacific")
+        dti = pd.date_range("2016-01-01", periods=6, tz="US/Pacific", unit="ns")
         dta = dti._data.reshape(3, 2)
 
         result = dta.mean(axis=0)
diff --git a/pandas/tests/arrays/floating/test_arithmetic.py b/pandas/tests/arrays/floating/test_arithmetic.py
index e4e26383ae42c..9b06fe5364137 100644
--- a/pandas/tests/arrays/floating/test_arithmetic.py
+++ b/pandas/tests/arrays/floating/test_arithmetic.py
@@ -185,7 +185,7 @@ def test_error_invalid_values(data, all_arithmetic_operators):
         ]
     )
     with pytest.raises(TypeError, match=msg):
-        ops(pd.Series(pd.date_range("20180101", periods=len(s))))
+        ops(pd.Series(pd.date_range("20180101", periods=len(s), unit="ns")))
 
 
 # Various
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index 4f4542da466b5..96c12aeb3ea80 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -141,7 +141,7 @@ def test_setitem_with_array_with_missing(dtype):
 
 
 def test_astype_roundtrip(dtype):
-    ser = pd.Series(pd.date_range("2000", periods=12))
+    ser = pd.Series(pd.date_range("2000", periods=12, unit="ns"))
     ser[0] = None
 
     casted = ser.astype(dtype)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 6a3568184b990..3e608b155c890 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -69,7 +69,9 @@ def datetime_index(freqstr):
     the DatetimeIndex behavior.
     """
     # TODO: non-monotone indexes; NaTs, different start dates, timezones
-    dti = pd.date_range(start=Timestamp("2000-01-01"), periods=100, freq=freqstr)
+    dti = pd.date_range(
+        start=Timestamp("2000-01-01"), periods=100, freq=freqstr, unit="ns"
+    )
     return dti
 
 
@@ -623,7 +625,9 @@ def arr1d(self, tz_naive_fixture, freqstr):
         timezones
         """
         tz = tz_naive_fixture
-        dti = pd.date_range("2016-01-01 01:01:00", periods=5, freq=freqstr, tz=tz)
+        dti = pd.date_range(
+            "2016-01-01 01:01:00", periods=5, freq=freqstr, tz=tz, unit="ns"
+        )
         dta = dti._data
         return dta
 
@@ -1092,7 +1096,7 @@ def test_to_timestamp(self, how, arr1d):
 
     def test_to_timestamp_roundtrip_bday(self):
         # Case where infer_freq inside would choose "D" instead of "B"
-        dta = pd.date_range("2021-10-18", periods=3, freq="B")._data
+        dta = pd.date_range("2021-10-18", periods=3, freq="B", unit="ns")._data
         parr = dta.to_period()
         result = parr.to_timestamp()
         assert result.freq == "B"
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 5a7cad77a9de0..7f1be30e5c022 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -41,7 +41,7 @@ def dtype(self, unit, tz_naive_fixture):
     def dta_dti(self, unit, dtype):
         tz = getattr(dtype, "tz", None)
 
-        dti = pd.date_range("2016-01-01", periods=55, freq="D", tz=tz)
+        dti = pd.date_range("2016-01-01", periods=55, freq="D", tz=tz, unit="ns")
         if tz is None:
             arr = np.asarray(dti).astype(f"M8[{unit}]")
         else:
@@ -114,7 +114,7 @@ def test_simple_new_requires_match(self, unit):
             DatetimeArray._simple_new(arr, dtype=wrong)
 
     def test_std_non_nano(self, unit):
-        dti = pd.date_range("2016-01-01", periods=55, freq="D")
+        dti = pd.date_range("2016-01-01", periods=55, freq="D", unit="ns")
         arr = np.asarray(dti).astype(f"M8[{unit}]")
 
         dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
@@ -508,7 +508,9 @@ def test_value_counts_preserves_tz(self):
 
     @pytest.mark.parametrize("method", ["pad", "backfill"])
     def test_fillna_preserves_tz(self, method):
-        dti = pd.date_range("2000-01-01", periods=5, freq="D", tz="US/Central")
+        dti = pd.date_range(
+            "2000-01-01", periods=5, freq="D", tz="US/Central", unit="ns"
+        )
         arr = DatetimeArray._from_sequence(dti, dtype=dti.dtype, copy=True)
         arr[2] = pd.NaT
 
@@ -568,7 +570,7 @@ def test_fillna_2d(self):
 
     def test_array_interface_tz(self):
         tz = "US/Central"
-        data = pd.date_range("2017", periods=2, tz=tz)._data
+        data = pd.date_range("2017", periods=2, tz=tz, unit="ns")._data
         result = np.asarray(data)
 
         expected = np.array(
@@ -591,7 +593,7 @@ def test_array_interface_tz(self):
         tm.assert_numpy_array_equal(result, expected)
 
     def test_array_interface(self):
-        data = pd.date_range("2017", periods=2)._data
+        data = pd.date_range("2017", periods=2, unit="ns")._data
         expected = np.array(
             ["2017-01-01T00:00:00", "2017-01-02T00:00:00"], dtype="datetime64[ns]"
         )
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
index 62717fda75594..1241ed2d6e6e0 100644
--- a/pandas/tests/base/test_conversion.py
+++ b/pandas/tests/base/test_conversion.py
@@ -583,7 +583,7 @@ def test_asarray_object_dt64(self, tz):
 
     def test_asarray_tz_naive(self):
         # This shouldn't produce a warning.
-        ser = Series(date_range("2000", periods=2))
+        ser = Series(date_range("2000", periods=2, unit="ns"))
         expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
         result = np.asarray(ser)
 
diff --git a/pandas/tests/base/test_value_counts.py b/pandas/tests/base/test_value_counts.py
index d792c36bd8da5..d60555246ca6a 100644
--- a/pandas/tests/base/test_value_counts.py
+++ b/pandas/tests/base/test_value_counts.py
@@ -346,8 +346,8 @@ def test_value_counts_object_inference_deprecated():
     ("index", "expected_index"),
     [
         [
-            pd.date_range("2016-01-01", periods=5, freq="D"),
-            pd.date_range("2016-01-01", periods=5, freq="D"),
+            pd.date_range("2016-01-01", periods=5, freq="D", unit="ns"),
+            pd.date_range("2016-01-01", periods=5, freq="D", unit="ns"),
         ],
         [
             pd.timedelta_range(Timedelta(0), periods=5, freq="h"),
@@ -359,7 +359,7 @@ def test_value_counts_object_inference_deprecated():
                 + [Timestamp("2016-01-02")]
                 + [Timestamp("2016-01-01") + Timedelta(days=i) for i in range(1, 5)]
             ),
-            DatetimeIndex(pd.date_range("2016-01-01", periods=5, freq="D")),
+            DatetimeIndex(pd.date_range("2016-01-01", periods=5, freq="D", unit="ns")),
         ],
         [
             TimedeltaIndex(
diff --git a/pandas/tests/copy_view/test_astype.py b/pandas/tests/copy_view/test_astype.py
index 0e879ee13d8c5..0075a7ed59795 100644
--- a/pandas/tests/copy_view/test_astype.py
+++ b/pandas/tests/copy_view/test_astype.py
@@ -166,7 +166,7 @@ def test_astype_different_datetime_resos():
 
 def test_astype_different_timezones():
     df = DataFrame(
-        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific")}
+        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific", unit="ns")}
     )
     result = df.astype("datetime64[ns, Europe/Berlin]")
     assert not result._mgr._has_no_reference(0)
@@ -175,7 +175,7 @@ def test_astype_different_timezones():
 
 def test_astype_different_timezones_different_reso():
     df = DataFrame(
-        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific")}
+        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific", unit="ns")}
     )
     result = df.astype("datetime64[ms, Europe/Berlin]")
     assert result._mgr._has_no_reference(0)
diff --git a/pandas/tests/dtypes/cast/test_infer_dtype.py b/pandas/tests/dtypes/cast/test_infer_dtype.py
index 94caa930900b6..86124c19db824 100644
--- a/pandas/tests/dtypes/cast/test_infer_dtype.py
+++ b/pandas/tests/dtypes/cast/test_infer_dtype.py
@@ -178,15 +178,15 @@ def test_infer_dtype_from_scalar(value, expected, using_infer_string):
         (np.array([[1.0, 2.0]]), np.float64),
         (Categorical(list("aabc")), "category"),
         (Categorical([1, 2, 3]), "category"),
-        (date_range("20160101", periods=3), np.dtype("=M8[ns]")),
+        (date_range("20160101", periods=3, unit="ns"), np.dtype("=M8[ns]")),
         (
-            date_range("20160101", periods=3, tz="US/Eastern"),
+            date_range("20160101", periods=3, tz="US/Eastern", unit="ns"),
             "datetime64[ns, US/Eastern]",
         ),
         (Series([1.0, 2, 3]), np.float64),
         (Series(list("abc")), np.object_),
         (
-            Series(date_range("20160101", periods=3, tz="US/Eastern")),
+            Series(date_range("20160101", periods=3, tz="US/Eastern", unit="ns")),
             "datetime64[ns, US/Eastern]",
         ),
     ],
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 1efa60d1fbc4c..81653bca439cc 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -1877,8 +1877,8 @@ def test_is_float(self):
         assert not is_float(Timedelta("1 days"))
 
     def test_is_datetime_dtypes(self):
-        ts = pd.date_range("20130101", periods=3)
-        tsa = pd.date_range("20130101", periods=3, tz="US/Eastern")
+        ts = pd.date_range("20130101", periods=3, unit="ns")
+        tsa = pd.date_range("20130101", periods=3, tz="US/Eastern", unit="ns")
 
         msg = "is_datetime64tz_dtype is deprecated"
 
diff --git a/pandas/tests/frame/conftest.py b/pandas/tests/frame/conftest.py
index b3140bad8276b..73b8f08957687 100644
--- a/pandas/tests/frame/conftest.py
+++ b/pandas/tests/frame/conftest.py
@@ -90,9 +90,9 @@ def timezone_frame():
     """
     df = DataFrame(
         {
-            "A": date_range("20130101", periods=3),
-            "B": date_range("20130101", periods=3, tz="US/Eastern"),
-            "C": date_range("20130101", periods=3, tz="CET"),
+            "A": date_range("20130101", periods=3, unit="ns"),
+            "B": date_range("20130101", periods=3, tz="US/Eastern", unit="ns"),
+            "C": date_range("20130101", periods=3, tz="CET", unit="ns"),
         }
     )
     df.iloc[1, 1] = NaT
diff --git a/pandas/tests/frame/indexing/test_getitem.py b/pandas/tests/frame/indexing/test_getitem.py
index 25d6e06a4c675..29124679664be 100644
--- a/pandas/tests/frame/indexing/test_getitem.py
+++ b/pandas/tests/frame/indexing/test_getitem.py
@@ -176,7 +176,9 @@ def test_getitem_iloc_dateoffset_days(self):
         # GH 46671
         df = DataFrame(
             list(range(10)),
-            index=date_range("01-01-2022", periods=10, freq=DateOffset(days=1)),
+            index=date_range(
+                "01-01-2022", periods=10, freq=DateOffset(days=1), unit="ns"
+            ),
         )
         result = df.loc["2022-01-01":"2022-01-03"]
         expected = DataFrame(
@@ -192,7 +194,7 @@ def test_getitem_iloc_dateoffset_days(self):
         df = DataFrame(
             list(range(10)),
             index=date_range(
-                "01-01-2022", periods=10, freq=DateOffset(days=1, hours=2)
+                "01-01-2022", periods=10, freq=DateOffset(days=1, hours=2), unit="ns"
             ),
         )
         result = df.loc["2022-01-01":"2022-01-03"]
@@ -208,7 +210,9 @@ def test_getitem_iloc_dateoffset_days(self):
 
         df = DataFrame(
             list(range(10)),
-            index=date_range("01-01-2022", periods=10, freq=DateOffset(minutes=3)),
+            index=date_range(
+                "01-01-2022", periods=10, freq=DateOffset(minutes=3), unit="ns"
+            ),
         )
         result = df.loc["2022-01-01":"2022-01-03"]
         tm.assert_frame_equal(result, df)
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index b6d23a2f9be24..2082fa8624739 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1125,7 +1125,7 @@ def test_loc_setitem_datetimelike_with_inference(self):
         # assignment of timedeltas with NaT
 
         one_hour = timedelta(hours=1)
-        df = DataFrame(index=date_range("20130101", periods=4))
+        df = DataFrame(index=date_range("20130101", periods=4, unit="ns"))
         df["A"] = np.array([1 * one_hour] * 4, dtype="m8[ns]")
         df.loc[:, "B"] = np.array([2 * one_hour] * 4, dtype="m8[ns]")
         df.loc[df.index[:3], "C"] = np.array([3 * one_hour] * 3, dtype="m8[ns]")
@@ -1133,7 +1133,7 @@ def test_loc_setitem_datetimelike_with_inference(self):
         df.loc[df.index[:3], "E"] = np.array([5 * one_hour] * 3, dtype="m8[ns]")
         df["F"] = np.timedelta64("NaT")
         df.loc[df.index[:-1], "F"] = np.array([6 * one_hour] * 3, dtype="m8[ns]")
-        df.loc[df.index[-3] :, "G"] = date_range("20130101", periods=3)
+        df.loc[df.index[-3] :, "G"] = date_range("20130101", periods=3, unit="ns")
         df["H"] = np.datetime64("NaT")
         result = df.dtypes
         expected = Series(
@@ -1562,7 +1562,7 @@ def test_object_casting_indexing_wraps_datetimelike():
     df = DataFrame(
         {
             "A": [1, 2],
-            "B": date_range("2000", periods=2),
+            "B": date_range("2000", periods=2, unit="ns"),
             "C": pd.timedelta_range("1 Day", periods=2),
         }
     )
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index 0de2455079027..f03cdfcb8f70e 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -171,7 +171,7 @@ def test_setitem_empty_columns(self):
         tm.assert_frame_equal(df, expected)
 
     def test_setitem_dt64_index_empty_columns(self):
-        rng = date_range("1/1/2000 00:00:00", "1/1/2000 1:59:50", freq="10s")
+        rng = date_range("1/1/2000 00:00:00", "1/1/2000 1:59:50", freq="10s", unit="ns")
         df = DataFrame(index=np.arange(len(rng)))
 
         df["A"] = rng
diff --git a/pandas/tests/frame/methods/test_asfreq.py b/pandas/tests/frame/methods/test_asfreq.py
index 1c3c41e2e0299..0c91dbb01acaa 100644
--- a/pandas/tests/frame/methods/test_asfreq.py
+++ b/pandas/tests/frame/methods/test_asfreq.py
@@ -186,7 +186,7 @@ def test_asfreq_fillvalue(self):
         tm.assert_series_equal(expected_series, actual_series)
 
     def test_asfreq_with_date_object_index(self, frame_or_series):
-        rng = date_range("1/1/2000", periods=20)
+        rng = date_range("1/1/2000", periods=20, unit="ns")
         ts = frame_or_series(np.random.default_rng(2).standard_normal(20), index=rng)
 
         ts2 = ts.copy()
diff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py
index 9fd1f3133c2f5..a364f85191c1d 100644
--- a/pandas/tests/frame/methods/test_astype.py
+++ b/pandas/tests/frame/methods/test_astype.py
@@ -734,7 +734,9 @@ def test_astype_tz_conversion(self):
         msg = "'d' is deprecated and will be removed in a future version."
         with tm.assert_produces_warning(Pandas4Warning, match=msg):
             val = {
-                "tz": date_range("2020-08-30", freq="d", periods=2, tz="Europe/London")
+                "tz": date_range(
+                    "2020-08-30", freq="d", periods=2, tz="Europe/London", unit="ns"
+                )
             }
         df = DataFrame(val)
         result = df.astype({"tz": "datetime64[ns, Europe/Berlin]"})
@@ -746,7 +748,11 @@ def test_astype_tz_conversion(self):
     @pytest.mark.parametrize("tz", ["UTC", "Europe/Berlin"])
     def test_astype_tz_object_conversion(self, tz):
         # GH 35973
-        val = {"tz": date_range("2020-08-30", freq="D", periods=2, tz="Europe/London")}
+        val = {
+            "tz": date_range(
+                "2020-08-30", freq="D", periods=2, tz="Europe/London", unit="ns"
+            )
+        }
         expected = DataFrame(val)
 
         # convert expected to object dtype from other tz str (independently tested)
diff --git a/pandas/tests/frame/methods/test_convert_dtypes.py b/pandas/tests/frame/methods/test_convert_dtypes.py
index 1444729a29d6d..013a2112c2935 100644
--- a/pandas/tests/frame/methods/test_convert_dtypes.py
+++ b/pandas/tests/frame/methods/test_convert_dtypes.py
@@ -67,7 +67,7 @@ def test_pyarrow_dtype_backend(self, using_nan_is_na):
                 "b": pd.Series(["x", "y", None], dtype=np.dtype("O")),
                 "c": pd.Series([True, False, None], dtype=np.dtype("O")),
                 "d": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
-                "e": pd.Series(pd.date_range("2022", periods=3)),
+                "e": pd.Series(pd.date_range("2022", periods=3, unit="ns")),
                 "f": pd.Series(pd.date_range("2022", periods=3, tz="UTC").as_unit("s")),
                 "g": pd.Series(pd.timedelta_range("1D", periods=3)),
             }
diff --git a/pandas/tests/frame/methods/test_diff.py b/pandas/tests/frame/methods/test_diff.py
index d846d7e5b77b9..61d718452b350 100644
--- a/pandas/tests/frame/methods/test_diff.py
+++ b/pandas/tests/frame/methods/test_diff.py
@@ -109,8 +109,8 @@ def test_diff_datetime_axis0(self, tz):
         # GH#18578
         df = DataFrame(
             {
-                0: date_range("2010", freq="D", periods=2, tz=tz),
-                1: date_range("2010", freq="D", periods=2, tz=tz),
+                0: date_range("2010", freq="D", periods=2, tz=tz, unit="ns"),
+                1: date_range("2010", freq="D", periods=2, tz=tz, unit="ns"),
             }
         )
 
@@ -128,8 +128,8 @@ def test_diff_datetime_axis1(self, tz):
         # GH#18578
         df = DataFrame(
             {
-                0: date_range("2010", freq="D", periods=2, tz=tz),
-                1: date_range("2010", freq="D", periods=2, tz=tz),
+                0: date_range("2010", freq="D", periods=2, tz=tz, unit="ns"),
+                1: date_range("2010", freq="D", periods=2, tz=tz, unit="ns"),
             }
         )
 
diff --git a/pandas/tests/frame/methods/test_dtypes.py b/pandas/tests/frame/methods/test_dtypes.py
index bf01ec73cf72b..372816d65604e 100644
--- a/pandas/tests/frame/methods/test_dtypes.py
+++ b/pandas/tests/frame/methods/test_dtypes.py
@@ -40,9 +40,9 @@ def test_empty_frame_dtypes(self):
     def test_datetime_with_tz_dtypes(self):
         tzframe = DataFrame(
             {
-                "A": date_range("20130101", periods=3),
-                "B": date_range("20130101", periods=3, tz="US/Eastern"),
-                "C": date_range("20130101", periods=3, tz="CET"),
+                "A": date_range("20130101", periods=3, unit="ns"),
+                "B": date_range("20130101", periods=3, tz="US/Eastern", unit="ns"),
+                "C": date_range("20130101", periods=3, tz="CET", unit="ns"),
             }
         )
         tzframe.iloc[1, 1] = pd.NaT
@@ -97,7 +97,7 @@ def test_dtypes_gh8722(self, float_string_frame):
     def test_dtypes_timedeltas(self):
         df = DataFrame(
             {
-                "A": Series(date_range("2012-1-1", periods=3, freq="D")),
+                "A": Series(date_range("2012-1-1", periods=3, freq="D", unit="ns")),
                 "B": Series([timedelta(days=i) for i in range(3)]),
             }
         )
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index d229fe5aaaa84..2c7f001604269 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -826,7 +826,10 @@ def test_fillna_with_none_object(test_frame, dtype):
 def test_fillna_out_of_bounds_datetime():
     # GH#61208
     df = DataFrame(
-        {"datetime": date_range("1/1/2011", periods=3, freq="h"), "value": [1, 2, 3]}
+        {
+            "datetime": date_range("1/1/2011", periods=3, freq="h", unit="ns"),
+            "value": [1, 2, 3],
+        }
     )
     df.iloc[0, 0] = None
 
diff --git a/pandas/tests/frame/methods/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py
index 631742d43263f..eded9d9473385 100644
--- a/pandas/tests/frame/methods/test_quantile.py
+++ b/pandas/tests/frame/methods/test_quantile.py
@@ -135,7 +135,7 @@ def test_axis_numeric_only_true(self, interp_method):
     def test_quantile_date_range(self, interp_method):
         # GH 2460
         interpolation, method = interp_method
-        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific", unit="ns")
         ser = Series(dti)
         df = DataFrame(ser)
 
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index 8ace0a48c8e28..571b54c904771 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -162,7 +162,7 @@ def test_reindex_tzaware_fill_value(self):
 
     def test_reindex_date_fill_value(self):
         # passing date to dt64 is deprecated; enforced in 2.0 to cast to object
-        arr = date_range("2016-01-01", periods=6).values.reshape(3, 2)
+        arr = date_range("2016-01-01", periods=6, unit="ns").values.reshape(3, 2)
         df = DataFrame(arr, columns=["A", "B"], index=range(3))
 
         ts = df.iloc[0, 0]
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index ff1113e4d5f95..38f3794cc5f64 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -809,7 +809,9 @@ def test_replace_for_new_dtypes(self, datetime_frame):
             (
                 DataFrame(
                     {
-                        "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                        "A": date_range(
+                            "20130101", periods=3, tz="US/Eastern", unit="ns"
+                        ),
                         "B": [0, np.nan, 2],
                     }
                 ),
@@ -1070,14 +1072,14 @@ def test_replace_datetimetz(self):
         # behaving poorly when presented with a datetime64[ns, tz]
         df = DataFrame(
             {
-                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "A": date_range("20130101", periods=3, tz="US/Eastern", unit="ns"),
                 "B": [0, np.nan, 2],
             }
         )
         result = df.replace(np.nan, 1)
         expected = DataFrame(
             {
-                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "A": date_range("20130101", periods=3, tz="US/Eastern", unit="ns"),
                 "B": Series([0, 1, 2], dtype="float64"),
             }
         )
@@ -1089,7 +1091,7 @@ def test_replace_datetimetz(self):
         result = df.replace(0, np.nan)
         expected = DataFrame(
             {
-                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "A": date_range("20130101", periods=3, tz="US/Eastern", unit="ns"),
                 "B": [np.nan, np.nan, 2],
             }
         )
diff --git a/pandas/tests/frame/methods/test_reset_index.py b/pandas/tests/frame/methods/test_reset_index.py
index 80227c0462329..060f3d5e16cb6 100644
--- a/pandas/tests/frame/methods/test_reset_index.py
+++ b/pandas/tests/frame/methods/test_reset_index.py
@@ -57,7 +57,9 @@ def test_set_reset(self):
         tm.assert_index_equal(df.index, idx)
 
     def test_set_index_reset_index_dt64tz(self):
-        idx = Index(date_range("20130101", periods=3, tz="US/Eastern"), name="foo")
+        idx = Index(
+            date_range("20130101", periods=3, tz="US/Eastern", unit="ns"), name="foo"
+        )
 
         # set/reset
         df = DataFrame({"A": [0, 1, 2]}, index=idx)
@@ -350,7 +352,7 @@ def test_reset_index_with_datetimeindex_cols(self, name):
         # GH#5818
         df = DataFrame(
             [[1, 2], [3, 4]],
-            columns=date_range("1/1/2013", "1/2/2013"),
+            columns=date_range("1/1/2013", "1/2/2013", unit="ns"),
             index=["A", "B"],
         )
         df.index.name = name
@@ -699,7 +701,7 @@ def test_reset_index_empty_frame_with_datetime64_multiindex_from_groupby(
 def test_reset_index_multiindex_nat():
     # GH 11479
     idx = range(3)
-    tstamp = date_range("2015-07-01", freq="D", periods=3)
+    tstamp = date_range("2015-07-01", freq="D", periods=3, unit="ns")
     df = DataFrame({"id": idx, "tstamp": tstamp, "a": list("abc")})
     df.loc[2, "tstamp"] = pd.NaT
     result = df.set_index(["id", "tstamp"]).reset_index("id")
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index 9ad98aa6b3090..cbef7f2956502 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -154,7 +154,9 @@ def test_shift_preserve_freqstr(self, periods, frame_or_series):
 
     def test_shift_dst(self, frame_or_series):
         # GH#13926
-        dates = date_range("2016-11-06", freq="h", periods=10, tz="US/Eastern")
+        dates = date_range(
+            "2016-11-06", freq="h", periods=10, tz="US/Eastern", unit="ns"
+        )
         obj = frame_or_series(dates)
 
         res = obj.shift(0)
@@ -176,7 +178,9 @@ def test_shift_dst(self, frame_or_series):
     @pytest.mark.parametrize("ex", [10, -10, 20, -20])
     def test_shift_dst_beyond(self, frame_or_series, ex):
         # GH#13926
-        dates = date_range("2016-11-06", freq="h", periods=10, tz="US/Eastern")
+        dates = date_range(
+            "2016-11-06", freq="h", periods=10, tz="US/Eastern", unit="ns"
+        )
         obj = frame_or_series(dates)
         res = obj.shift(ex)
         exp = frame_or_series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
diff --git a/pandas/tests/frame/methods/test_to_csv.py b/pandas/tests/frame/methods/test_to_csv.py
index e2bf84e3bd8c3..ababcaa11377c 100644
--- a/pandas/tests/frame/methods/test_to_csv.py
+++ b/pandas/tests/frame/methods/test_to_csv.py
@@ -359,7 +359,7 @@ def test_to_csv_nrows(self, nrows, temp_file):
             columns=Index(list("abcd"), dtype=object),
         )
         result, expected = self._return_result_expected(df, 1000, temp_file, "dt", "s")
-        expected.index = expected.index.astype("M8[ns]")
+        expected.index = expected.index.astype("M8[us]")
         tm.assert_frame_equal(result, expected, check_names=False)
 
     @pytest.mark.slow
@@ -390,9 +390,13 @@ def test_to_csv_idx_types(self, nrows, r_idx_type, c_idx_type, ncols, temp_file)
             r_idx_type,
             c_idx_type,
         )
-        if r_idx_type in ["dt", "p"]:
+        if r_idx_type == "dt":
+            expected.index = expected.index.astype("M8[us]")
+        elif r_idx_type == "p":
             expected.index = expected.index.astype("M8[ns]")
-        if c_idx_type in ["dt", "p"]:
+        if c_idx_type == "dt":
+            expected.columns = expected.columns.astype("M8[us]")
+        elif c_idx_type == "p":
             expected.columns = expected.columns.astype("M8[ns]")
         tm.assert_frame_equal(result, expected, check_names=False)
 
@@ -1194,7 +1198,7 @@ def test_to_csv_with_dst_transitions(self, td, temp_file):
     )
     def test_to_csv_with_dst_transitions_with_pickle(self, start, end, temp_file):
         # GH11619
-        idx = date_range(start, end, freq="h", tz="Europe/Paris")
+        idx = date_range(start, end, freq="h", tz="Europe/Paris", unit="ns")
         idx = idx._with_freq(None)  # freq does not round-trip
         idx._data._freq = None  # otherwise there is trouble on unpickle
         df = DataFrame({"values": 1, "idx": idx}, index=idx)
diff --git a/pandas/tests/frame/methods/test_to_numpy.py b/pandas/tests/frame/methods/test_to_numpy.py
index aace5dfaa8dff..c9ab0dfccefc4 100644
--- a/pandas/tests/frame/methods/test_to_numpy.py
+++ b/pandas/tests/frame/methods/test_to_numpy.py
@@ -46,7 +46,7 @@ def test_to_numpy_mixed_dtype_to_str(self):
 
     def test_to_numpy_datetime_with_na(self):
         # GH #53115
-        dti = date_range("2016-01-01", periods=3)
+        dti = date_range("2016-01-01", periods=3, unit="ns")
         df = DataFrame(dti)
         df.iloc[0, 0] = NaT
         expected = np.array([[np.nan], [1.45169280e18], [1.45177920e18]])
diff --git a/pandas/tests/frame/methods/test_to_records.py b/pandas/tests/frame/methods/test_to_records.py
index fab90b112fa94..99d92f4ec6332 100644
--- a/pandas/tests/frame/methods/test_to_records.py
+++ b/pandas/tests/frame/methods/test_to_records.py
@@ -18,7 +18,7 @@
 
 class TestDataFrameToRecords:
     def test_to_records_timeseries(self):
-        index = date_range("1/1/2000", periods=10)
+        index = date_range("1/1/2000", periods=10, unit="ns")
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 3)),
             index=index,
@@ -121,9 +121,9 @@ def test_to_records_index_dtype(self):
         # GH 47263: consistent data types for Index and MultiIndex
         df = DataFrame(
             {
-                1: date_range("2022-01-01", periods=2),
-                2: date_range("2022-01-01", periods=2),
-                3: date_range("2022-01-01", periods=2),
+                1: date_range("2022-01-01", periods=2, unit="ns"),
+                2: date_range("2022-01-01", periods=2, unit="ns"),
+                3: date_range("2022-01-01", periods=2, unit="ns"),
             }
         )
 
diff --git a/pandas/tests/frame/methods/test_to_timestamp.py b/pandas/tests/frame/methods/test_to_timestamp.py
index 0e7e1d595d6be..d5d1bc8fe077d 100644
--- a/pandas/tests/frame/methods/test_to_timestamp.py
+++ b/pandas/tests/frame/methods/test_to_timestamp.py
@@ -21,6 +21,7 @@ def _get_with_delta(delta, freq="YE-DEC"):
         to_datetime("1/1/2001") + delta,
         to_datetime("12/31/2009") + delta,
         freq=freq,
+        unit="ns",
     )
 
 
@@ -36,7 +37,7 @@ def test_to_timestamp(self, frame_or_series):
         obj["mix"] = "a"
         obj = tm.get_obj(obj, frame_or_series)
 
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="YE-DEC")
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="YE-DEC", unit="ns")
         exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
         result = obj.to_timestamp("D", "end")
         tm.assert_index_equal(result.index, exp_index)
@@ -44,7 +45,7 @@ def test_to_timestamp(self, frame_or_series):
         if frame_or_series is Series:
             assert result.name == "A"
 
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN")
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN", unit="ns")
         result = obj.to_timestamp("D", "start")
         tm.assert_index_equal(result.index, exp_index)
 
@@ -82,13 +83,13 @@ def test_to_timestamp_columns(self):
         # columns
         df = df.T
 
-        exp_index = date_range("1/1/2001", end="12/31/2009", freq="YE-DEC")
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="YE-DEC", unit="ns")
         exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
         result = df.to_timestamp("D", "end", axis=1)
         tm.assert_index_equal(result.columns, exp_index)
         tm.assert_numpy_array_equal(result.values, df.values)
 
-        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN")
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="YS-JAN", unit="ns")
         result = df.to_timestamp("D", "start", axis=1)
         tm.assert_index_equal(result.columns, exp_index)
 
@@ -112,7 +113,7 @@ def test_to_timestamp_columns(self):
 
         result1 = df.to_timestamp("5min", axis=1)
         result2 = df.to_timestamp("min", axis=1)
-        expected = date_range("2001-01-01", "2009-01-01", freq="YS")
+        expected = date_range("2001-01-01", "2009-01-01", freq="YS", unit="ns")
         assert isinstance(result1.columns, DatetimeIndex)
         assert isinstance(result2.columns, DatetimeIndex)
         tm.assert_numpy_array_equal(result1.columns.asi8, expected.asi8)
@@ -137,7 +138,9 @@ def test_to_timestamp_hourly(self, frame_or_series):
         if frame_or_series is not Series:
             obj = obj.to_frame()
 
-        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="h")
+        exp_index = date_range(
+            "1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="h", unit="ns"
+        )
         result = obj.to_timestamp(how="end")
         exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
         tm.assert_index_equal(result.index, exp_index)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 5e50759d34014..7b361f880ee14 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -115,7 +115,7 @@ def test_frame_in_list(self):
             [
                 {
                     "a": np.random.default_rng(2).integers(10, size=10),
-                    "b": pd.date_range("20010101", periods=10),
+                    "b": pd.date_range("20010101", periods=10, unit="ns"),
                 },
                 {
                     "a": np.random.default_rng(2).integers(10, size=10),
@@ -129,13 +129,13 @@ def test_frame_in_list(self):
                 },
                 {
                     "a": np.random.default_rng(2).integers(10, size=10),
-                    "b": pd.date_range("20010101", periods=10),
+                    "b": pd.date_range("20010101", periods=10, unit="ns"),
                 },
             ],
             [
                 {
-                    "a": pd.date_range("20010101", periods=10),
-                    "b": pd.date_range("20010101", periods=10),
+                    "a": pd.date_range("20010101", periods=10, unit="ns"),
+                    "b": pd.date_range("20010101", periods=10, unit="ns"),
                 },
                 {
                     "a": np.random.default_rng(2).integers(10, size=10),
@@ -145,11 +145,11 @@ def test_frame_in_list(self):
             [
                 {
                     "a": np.random.default_rng(2).integers(10, size=10),
-                    "b": pd.date_range("20010101", periods=10),
+                    "b": pd.date_range("20010101", periods=10, unit="ns"),
                 },
                 {
-                    "a": pd.date_range("20010101", periods=10),
-                    "b": pd.date_range("20010101", periods=10),
+                    "a": pd.date_range("20010101", periods=10, unit="ns"),
+                    "b": pd.date_range("20010101", periods=10, unit="ns"),
                 },
             ],
         ],
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 896a795adac43..a3b18086a95f9 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2907,7 +2907,7 @@ class TestDataFrameConstructorWithDatetimeTZ:
     def test_construction_preserves_tzaware_dtypes(self, tz):
         # after GH#7822
         # these retain the timezones on dict construction
-        dr = date_range("2011/1/1", "2012/1/1", freq="W-FRI")
+        dr = date_range("2011/1/1", "2012/1/1", freq="W-FRI", unit="ns")
         dr_tz = dr.tz_localize(tz)
         df = DataFrame({"A": "foo", "B": dr_tz}, index=dr)
         tz_expected = DatetimeTZDtype("ns", dr_tz.tzinfo)
@@ -3013,7 +3013,7 @@ def test_frame_datetime64_mixed_index_ctor_1681(self):
     def test_frame_timeseries_column(self):
         # GH19157
         dr = date_range(
-            start="20130101T10:00:00", periods=3, freq="min", tz="US/Eastern"
+            start="20130101T10:00:00", periods=3, freq="min", tz="US/Eastern", unit="ns"
         )
         result = DataFrame(dr, columns=["timestamps"])
         expected = DataFrame(
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index b599be5d042fe..24e195bc2fe0a 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -529,7 +529,7 @@ def test_date_index_query_with_NaT_duplicates(self, engine, parser):
     def test_date_query_with_non_date(self, engine, parser):
         n = 10
         df = DataFrame(
-            {"dates": date_range("1/1/2012", periods=n), "nondate": np.arange(n)}
+            {"dates": date_range("1/1/2012", periods=n, unit="ns"), "nondate": np.arange(n)}
         )
 
         result = df.query("dates == nondate", parser=parser, engine=engine)
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 4d235587c2407..f67590b100451 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -687,8 +687,8 @@ def test_mode_empty_df(self):
     def test_operators_timedelta64(self):
         df = DataFrame(
             {
-                "A": date_range("2012-1-1", periods=3, freq="D"),
-                "B": date_range("2012-1-2", periods=3, freq="D"),
+                "A": date_range("2012-1-1", periods=3, freq="D", unit="ns"),
+                "B": date_range("2012-1-2", periods=3, freq="D", unit="ns"),
                 "C": Timestamp("20120101") - timedelta(minutes=5, seconds=5),
             }
         )
@@ -761,8 +761,8 @@ def test_operators_timedelta64(self):
         # GH 3106
         df = DataFrame(
             {
-                "time": date_range("20130102", periods=5),
-                "time2": date_range("20130105", periods=5),
+                "time": date_range("20130102", periods=5, unit="ns"),
+                "time2": date_range("20130105", periods=5, unit="ns"),
             }
         )
         df["off1"] = df["time2"] - df["time"]
diff --git a/pandas/tests/generic/test_to_xarray.py b/pandas/tests/generic/test_to_xarray.py
index ea1cc2e1e0e2a..ccbae4a37ab9d 100644
--- a/pandas/tests/generic/test_to_xarray.py
+++ b/pandas/tests/generic/test_to_xarray.py
@@ -13,6 +13,11 @@
 
 xarray = pytest.importorskip("xarray")
 
+if xarray is not None and Version(xarray.__version__) < Version("2025.1.0"):
+    pytestmark = pytest.mark.filterwarnings(
+        "ignore:Converting non-nanosecond precision datetime:UserWarning"
+    )
+
 
 class TestDataFrameToXArray:
     @pytest.fixture
@@ -77,6 +82,9 @@ def test_to_xarray_with_multiindex(self, df, using_infer_string):
         expected["f"] = expected["f"].astype(
             object if not using_infer_string else "str"
         )
+        if Version(xarray.__version__) < Version("2025.1.0"):
+            expected["g"] = expected["g"].astype("M8[ns]")
+            expected["h"] = expected["h"].astype("M8[ns, US/Eastern]")
         expected.columns.name = None
         tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/groupby/methods/test_quantile.py b/pandas/tests/groupby/methods/test_quantile.py
index 815513fe96009..25bac63034125 100644
--- a/pandas/tests/groupby/methods/test_quantile.py
+++ b/pandas/tests/groupby/methods/test_quantile.py
@@ -410,7 +410,7 @@ def test_timestamp_groupby_quantile(unit):
 
 def test_groupby_quantile_dt64tz_period():
     # GH#51373
-    dti = pd.date_range("2016-01-01", periods=1000)
+    dti = pd.date_range("2016-01-01", periods=1000, unit="ns")
     df = pd.Series(dti).to_frame().copy()
     df[1] = dti.tz_localize("US/Pacific")
     df[2] = dti.to_period("D")
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 4955b1fe0da54..9d238a745fd30 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -2269,7 +2269,7 @@ def test_groupby_cumsum_skipna_false():
 
 def test_groupby_cumsum_timedelta64():
     # GH#46216 don't ignore is_datetimelike in libgroupby.group_cumsum
-    dti = date_range("2016-01-01", periods=5)
+    dti = date_range("2016-01-01", periods=5, unit="ns")
     ser = Series(dti) - dti[0]
     ser[2] = pd.NaT
 
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 81e022de991ea..14d1a0ed75a66 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -111,7 +111,7 @@ def test_transform_fast2():
         {
             "grouping": [0, 1, 1, 3],
             "f": [1.1, 2.1, 3.1, 4.5],
-            "d": date_range("2014-1-1", "2014-1-4"),
+            "d": date_range("2014-1-1", "2014-1-4", unit="ns"),
             "i": [1, 2, 3, 4],
         },
         columns=["grouping", "f", "i", "d"],
@@ -401,7 +401,10 @@ def test_transform_function_aliases(df):
 def test_series_fast_transform_date():
     # GH 13191
     df = DataFrame(
-        {"grouping": [np.nan, 1, 1, 3], "d": date_range("2014-1-1", "2014-1-4")}
+        {
+            "grouping": [np.nan, 1, 1, 3],
+            "d": date_range("2014-1-1", "2014-1-4", unit="ns"),
+        }
     )
     result = df.groupby("grouping")["d"].transform("first")
     dates = [
@@ -1010,7 +1013,7 @@ def test_groupby_transform_timezone_column(func):
 )
 def test_groupby_transform_with_datetimes(func, values):
     # GH 15306
-    dates = date_range("1/1/2011", periods=10, freq="D")
+    dates = date_range("1/1/2011", periods=10, freq="D", unit="ns")
 
     stocks = DataFrame({"price": np.arange(10.0)}, index=dates)
     stocks["week_id"] = dates.isocalendar().week
diff --git a/pandas/tests/indexes/datetimes/methods/test_astype.py b/pandas/tests/indexes/datetimes/methods/test_astype.py
index 62be8903da206..9ed7db4c6d9fb 100644
--- a/pandas/tests/indexes/datetimes/methods/test_astype.py
+++ b/pandas/tests/indexes/datetimes/methods/test_astype.py
@@ -83,9 +83,11 @@ def test_astype_with_tz(self):
 
     def test_astype_tzaware_to_tzaware(self):
         # GH 18951: tz-aware to tz-aware
-        idx = date_range("20170101", periods=4, tz="US/Pacific")
+        idx = date_range("20170101", periods=4, tz="US/Pacific", unit="ns")
         result = idx.astype("datetime64[ns, US/Eastern]")
-        expected = date_range("20170101 03:00:00", periods=4, tz="US/Eastern")
+        expected = date_range(
+            "20170101 03:00:00", periods=4, tz="US/Eastern", unit="ns"
+        )
         tm.assert_index_equal(result, expected)
         assert result.freq == expected.freq
 
@@ -314,7 +316,7 @@ def test_dti_astype_period(self):
 class TestAstype:
     @pytest.mark.parametrize("tz", [None, "US/Central"])
     def test_astype_category(self, tz):
-        obj = date_range("2000", periods=2, tz=tz, name="idx")
+        obj = date_range("2000", periods=2, tz=tz, name="idx", unit="ns")
         result = obj.astype("category")
         dti = DatetimeIndex(["2000-01-01", "2000-01-02"], tz=tz).as_unit("ns")
         expected = pd.CategoricalIndex(
diff --git a/pandas/tests/indexes/datetimes/methods/test_insert.py b/pandas/tests/indexes/datetimes/methods/test_insert.py
index 4a5b7bcc1a86f..b9fb9adbd9ee1 100644
--- a/pandas/tests/indexes/datetimes/methods/test_insert.py
+++ b/pandas/tests/indexes/datetimes/methods/test_insert.py
@@ -212,7 +212,9 @@ def test_insert_mismatched_tzawareness(self):
     def test_insert_mismatched_tz(self):
         # see GH#7299
         # pre-2.0 with mismatched tzs we would cast to object
-        idx = date_range("1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", name="idx")
+        idx = date_range(
+            "1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", unit="ns", name="idx"
+        )
 
         # mismatched tz -> cast to object (could reasonably cast to same tz or UTC)
         item = Timestamp("2000-01-04", tz="US/Eastern")
diff --git a/pandas/tests/indexes/datetimes/methods/test_round.py b/pandas/tests/indexes/datetimes/methods/test_round.py
index b023542ba0a4c..0570263be5b67 100644
--- a/pandas/tests/indexes/datetimes/methods/test_round.py
+++ b/pandas/tests/indexes/datetimes/methods/test_round.py
@@ -104,7 +104,7 @@ def test_round4(self, tz_naive_fixture):
     def test_no_rounding_occurs(self, tz_naive_fixture):
         # GH 21262
         tz = tz_naive_fixture
-        rng = date_range(start="2016-01-01", periods=5, freq="2Min", tz=tz)
+        rng = date_range(start="2016-01-01", periods=5, freq="2Min", tz=tz, unit="ns")
 
         expected_rng = DatetimeIndex(
             [
@@ -192,7 +192,7 @@ def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
         ],
     )
     def test_round_int64(self, start, index_freq, periods, round_freq):
-        dt = date_range(start=start, freq=index_freq, periods=periods)
+        dt = date_range(start=start, freq=index_freq, periods=periods, unit="ns")
         unit = to_offset(round_freq).nanos
 
         # test floor
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index cd4a142dd5b30..78a0ebd741e8b 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -118,11 +118,11 @@ def test_to_period_infer(self):
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_period_dt64_round_trip(self):
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        dti = date_range("1/1/2000", "1/7/2002", freq="B", unit="ns")
         pi = dti.to_period()
         tm.assert_index_equal(pi.to_timestamp(), dti)
 
-        dti = date_range("1/1/2000", "1/7/2002", freq="B")
+        dti = date_range("1/1/2000", "1/7/2002", freq="B", unit="ns")
         pi = dti.to_period(freq="h")
         tm.assert_index_equal(pi.to_timestamp(), dti)
 
diff --git a/pandas/tests/indexes/datetimes/methods/test_tz_localize.py b/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
index b5616cda64115..86738b9685839 100644
--- a/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
+++ b/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
@@ -216,11 +216,13 @@ def test_dti_tz_localize_tzlocal(self):
         offset = dateutil.tz.tzlocal().utcoffset(datetime(2011, 1, 1))
         offset = int(offset.total_seconds() * 1000000000)
 
-        dti = date_range(start="2001-01-01", end="2001-03-01")
+        dti = date_range(start="2001-01-01", end="2001-03-01", unit="ns")
         dti2 = dti.tz_localize(dateutil.tz.tzlocal())
         tm.assert_numpy_array_equal(dti2.asi8 + offset, dti.asi8)
 
-        dti = date_range(start="2001-01-01", end="2001-03-01", tz=dateutil.tz.tzlocal())
+        dti = date_range(
+            start="2001-01-01", end="2001-03-01", tz=dateutil.tz.tzlocal(), unit="ns"
+        )
         dti2 = dti.tz_localize(None)
         tm.assert_numpy_array_equal(dti2.asi8 - offset, dti.asi8)
 
diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index 1c19133fff483..f5ada5a191250 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -32,7 +32,11 @@ def test_sub_datetime_preserves_freq(self, tz_naive_fixture):
         #  is not preserved by subtraction.  Ticks offsets like "24h"
         #  are still preserved
         dti = date_range(
-            "2016-01-01", periods=12, tz=tz_naive_fixture, freq=offsets.Hour(24)
+            "2016-01-01",
+            periods=12,
+            tz=tz_naive_fixture,
+            freq=offsets.Hour(24),
+            unit="ns",
         )
 
         res = dti - dti[0]
@@ -43,7 +47,7 @@ def test_sub_datetime_preserves_freq(self, tz_naive_fixture):
     def test_sub_datetime_preserves_freq_across_dst(self):
         # GH#48818
         ts = Timestamp("2016-03-11", tz="US/Pacific")
-        dti = date_range(ts, periods=4)
+        dti = date_range(ts, periods=4, unit="ns")
 
         res = dti - dti[0]
         expected = TimedeltaIndex(
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index d3de0648a6ba3..4aa4c81558fa9 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -44,7 +44,7 @@ def test_from_dt64_unsupported_unit(self):
 
     def test_explicit_tz_none(self):
         # GH#48659
-        dti = date_range("2016-01-01", periods=10, tz="UTC")
+        dti = date_range("2016-01-01", periods=10, tz="UTC", unit="ns")
 
         msg = "Passed data is timezone-aware, incompatible with 'tz=None'"
         with pytest.raises(ValueError, match=msg):
@@ -73,7 +73,7 @@ def test_freq_validation_with_nat(self):
     @pytest.mark.parametrize(
         "index",
         [
-            date_range("2016-01-01", periods=5, tz="US/Pacific"),
+            date_range("2016-01-01", periods=5, tz="US/Pacific", unit="ns"),
             pd.timedelta_range("1 Day", periods=5),
         ],
     )
@@ -151,16 +151,16 @@ def test_constructor_from_sparse_array(self):
     def test_construction_caching(self):
         df = pd.DataFrame(
             {
-                "dt": date_range("20130101", periods=3),
+                "dt": date_range("20130101", periods=3, unit="ns"),
                 "dttz": date_range(
-                    "20130101", periods=3, tz=zoneinfo.ZoneInfo("US/Eastern")
+                    "20130101", periods=3, tz=zoneinfo.ZoneInfo("US/Eastern"), unit="ns"
                 ),
                 "dt_with_null": [
                     Timestamp("20130101"),
                     pd.NaT,
                     Timestamp("20130103"),
                 ],
-                "dtns": date_range("20130101", periods=3, freq="ns"),
+                "dtns": date_range("20130101", periods=3, freq="ns", unit="ns"),
             }
         )
         assert df.dttz.dtype.tz.key == "US/Eastern"
@@ -171,7 +171,7 @@ def test_construction_caching(self):
     )
     def test_construction_with_alt(self, kwargs, tz_aware_fixture):
         tz = tz_aware_fixture
-        i = date_range("20130101", periods=5, freq="h", tz=tz)
+        i = date_range("20130101", periods=5, freq="h", tz=tz, unit="ns")
         kwargs = {key: attrgetter(val)(i) for key, val in kwargs.items()}
         result = DatetimeIndex(i, **kwargs)
         tm.assert_index_equal(i, result)
@@ -182,7 +182,7 @@ def test_construction_with_alt(self, kwargs, tz_aware_fixture):
     )
     def test_construction_with_alt_tz_localize(self, kwargs, tz_aware_fixture):
         tz = tz_aware_fixture
-        i = date_range("20130101", periods=5, freq="h", tz=tz)
+        i = date_range("20130101", periods=5, freq="h", tz=tz, unit="ns")
         i = i._with_freq(None)
         kwargs = {key: attrgetter(val)(i) for key, val in kwargs.items()}
 
@@ -757,7 +757,7 @@ def test_constructor_start_end_with_tz(self, tz):
         # GH 18595
         start = Timestamp("2013-01-01 06:00:00", tz="America/Los_Angeles")
         end = Timestamp("2013-01-02 06:00:00", tz="America/Los_Angeles")
-        result = date_range(freq="D", start=start, end=end, tz=tz)
+        result = date_range(freq="D", start=start, end=end, tz=tz, unit="ns")
         expected = DatetimeIndex(
             ["2013-01-01 06:00:00", "2013-01-02 06:00:00"],
             dtype="M8[ns, America/Los_Angeles]",
@@ -816,6 +816,7 @@ def test_construction_from_replaced_timestamps_with_dst(self):
             Timestamp(2005, 12, 31),
             freq="YE-DEC",
             tz="Australia/Melbourne",
+            unit="ns",
         )
         result = DatetimeIndex([x.replace(month=6, day=1) for x in index])
         expected = DatetimeIndex(
@@ -859,7 +860,7 @@ def test_constructor_with_ambiguous_keyword_arg(self):
         start = Timestamp(year=2020, month=11, day=1, hour=1).tz_localize(
             timezone, ambiguous=False
         )
-        result = date_range(start=start, periods=2, ambiguous=False)
+        result = date_range(start=start, periods=2, ambiguous=False, unit="ns")
         tm.assert_index_equal(result, expected)
 
         # ambiguous keyword in end
@@ -867,7 +868,7 @@ def test_constructor_with_ambiguous_keyword_arg(self):
         end = Timestamp(year=2020, month=11, day=2, hour=1).tz_localize(
             timezone, ambiguous=False
         )
-        result = date_range(end=end, periods=2, ambiguous=False)
+        result = date_range(end=end, periods=2, ambiguous=False, unit="ns")
         tm.assert_index_equal(result, expected)
 
     def test_constructor_with_nonexistent_keyword_arg(self, warsaw):
@@ -878,7 +879,7 @@ def test_constructor_with_nonexistent_keyword_arg(self, warsaw):
         start = Timestamp("2015-03-29 02:30:00").tz_localize(
             timezone, nonexistent="shift_forward"
         )
-        result = date_range(start=start, periods=2, freq="h")
+        result = date_range(start=start, periods=2, freq="h", unit="ns")
         expected = DatetimeIndex(
             [
                 Timestamp("2015-03-29 03:00:00+02:00", tz=timezone),
@@ -890,7 +891,7 @@ def test_constructor_with_nonexistent_keyword_arg(self, warsaw):
 
         # nonexistent keyword in end
         end = start
-        result = date_range(end=end, periods=2, freq="h")
+        result = date_range(end=end, periods=2, freq="h", unit="ns")
         expected = DatetimeIndex(
             [
                 Timestamp("2015-03-29 01:00:00+01:00", tz=timezone),
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index bb701adaf4c4f..44e4ee801b289 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -242,11 +242,11 @@ def test_date_range_int64_overflow_non_recoverable(self):
         # case with start later than 1970-01-01, overflow int64 but not uint64
         msg = "Cannot generate range with"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(start="1970-02-01", periods=106752 * 24, freq="h")
+            date_range(start="1970-02-01", periods=106752 * 24, freq="h", unit="ns")
 
         # case with end before 1970-01-01, overflow int64 but not uint64
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(end="1969-11-14", periods=106752 * 24, freq="h")
+            date_range(end="1969-11-14", periods=106752 * 24, freq="h", unit="ns")
 
     @pytest.mark.slow
     @pytest.mark.parametrize(
@@ -271,9 +271,9 @@ def test_date_range_out_of_bounds(self):
         # GH#14187
         msg = "Cannot generate range"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range("2016-01-01", periods=100000, freq="D")
+            date_range("2016-01-01", periods=100000, freq="D", unit="ns")
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(end="1763-10-12", periods=100000, freq="D")
+            date_range(end="1763-10-12", periods=100000, freq="D", unit="ns")
 
     def test_date_range_gen_error(self):
         rng = date_range("1/1/2000 00:00", "1/1/2000 00:18", freq="5min")
@@ -287,7 +287,7 @@ def test_date_range_normalize(self):
 
         offset = timedelta(2)
         expected = DatetimeIndex(
-            [snap + i * offset for i in range(n)], dtype="M8[ns]", freq=offset
+            [snap + i * offset for i in range(n)], dtype="M8[us]", freq=offset
         )
 
         tm.assert_index_equal(rng, expected)
@@ -687,13 +687,13 @@ def test_freq_divides_end_in_nanos(self):
         result_2 = date_range("2005-01-13 10:00", "2005-01-13 16:00", freq="345min")
         expected_1 = DatetimeIndex(
             ["2005-01-12 10:00:00", "2005-01-12 15:45:00"],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="345min",
             tz=None,
         )
         expected_2 = DatetimeIndex(
             ["2005-01-13 10:00:00", "2005-01-13 15:45:00"],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="345min",
             tz=None,
         )
@@ -1014,10 +1014,10 @@ def test_precision_finer_than_offset(self):
             "2015-06-21 00:00:03",
         ]
         expected1 = DatetimeIndex(
-            expected1_list, dtype="datetime64[ns]", freq="QE-DEC", tz=None
+            expected1_list, dtype="datetime64[us]", freq="QE-DEC", tz=None
         )
         expected2 = DatetimeIndex(
-            expected2_list, dtype="datetime64[ns]", freq="W-SUN", tz=None
+            expected2_list, dtype="datetime64[us]", freq="W-SUN", tz=None
         )
         tm.assert_index_equal(result1, expected1)
         tm.assert_index_equal(result2, expected2)
@@ -1110,7 +1110,7 @@ def test_bday_near_overflow(self):
         # GH#24252 avoid doing unnecessary addition that _would_ overflow
         start = Timestamp.max.floor("D").to_pydatetime()
         rng = date_range(start, end=None, periods=1, freq="B")
-        expected = DatetimeIndex([start], freq="B").as_unit("ns")
+        expected = DatetimeIndex([start], freq="B")
         tm.assert_index_equal(rng, expected)
 
     def test_bday_overflow_error(self):
@@ -1118,7 +1118,7 @@ def test_bday_overflow_error(self):
         msg = "Out of bounds nanosecond timestamp"
         start = Timestamp.max.floor("D").to_pydatetime()
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(start, periods=2, freq="B")
+            date_range(start, periods=2, freq="B", unit="ns")
 
 
 class TestCustomDateRange:
@@ -1257,7 +1257,7 @@ def test_range_with_millisecond_resolution(self, start_end):
         # https://github.com/pandas-dev/pandas/issues/24110
         start, end = start_end
         result = date_range(start=start, end=end, periods=2, inclusive="left")
-        expected = DatetimeIndex([start], dtype="M8[ns, UTC]")
+        expected = DatetimeIndex([start], dtype="M8[us, UTC]")
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -1275,7 +1275,7 @@ def test_range_with_millisecond_resolution(self, start_end):
     def test_range_with_timezone_and_custombusinessday(self, start, period, expected):
         # GH49441
         result = date_range(start=start, periods=period, freq="C")
-        expected = DatetimeIndex(expected).as_unit("ns")
+        expected = DatetimeIndex(expected).as_unit("us")
         tm.assert_index_equal(result, expected)
 
     def test_data_range_custombusinessday_partial_time(self, unit):
@@ -1316,7 +1316,7 @@ def test_cdaterange_cbh(self):
                 "2009-03-13 15:00:00",
                 "2009-03-13 16:00:00",
             ],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="cbh",
         )
         tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index 04334a1d8d0c8..e1ce0c816152b 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -99,7 +99,7 @@ def test_ns_index(self):
 
     def test_asarray_tz_naive(self):
         # This shouldn't produce a warning.
-        idx = date_range("2000", periods=2)
+        idx = date_range("2000", periods=2, unit="ns")
         # M8[ns] by default
         result = np.asarray(idx)
 
@@ -114,7 +114,7 @@ def test_asarray_tz_naive(self):
 
     def test_asarray_tz_aware(self):
         tz = "US/Central"
-        idx = date_range("2000", periods=2, tz=tz)
+        idx = date_range("2000", periods=2, tz=tz, unit="ns")
         expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]")
         result = np.asarray(idx, dtype="datetime64[ns]")
 
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index 11877024e7be0..8bb02563233a4 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -158,7 +158,7 @@ def test_where_other(self):
         tm.assert_index_equal(result, i2)
 
     def test_where_invalid_dtypes(self):
-        dti = date_range("20130101", periods=3, tz="US/Eastern")
+        dti = date_range("20130101", periods=3, tz="US/Eastern", unit="ns")
 
         tail = dti[2:].tolist()
         i2 = Index([pd.NaT, pd.NaT] + tail)
@@ -637,7 +637,7 @@ def test_get_indexer_pad_requires_monotonicity(self):
 class TestMaybeCastSliceBound:
     def test_maybe_cast_slice_bounds_empty(self):
         # GH#14354
-        empty_idx = date_range(freq="1h", periods=0, end="2015")
+        empty_idx = date_range(freq="1h", periods=0, end="2015", unit="ns")
 
         right = empty_idx._maybe_cast_slice_bound("2015-01-02", "right")
         exp = Timestamp("2015-01-02 23:59:59.999999999")
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index bac9548b932c1..5a1c0a136a828 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -14,7 +14,7 @@
 class TestDatetimeIndexOps:
     def test_infer_freq(self, freq_sample):
         # GH 11018
-        idx = date_range("2011-01-01 09:00:00", freq=freq_sample, periods=10)
+        idx = date_range("2011-01-01 09:00:00", freq=freq_sample, periods=10, unit="ns")
         result = DatetimeIndex(idx.asi8, freq="infer")
         tm.assert_index_equal(idx, result)
         assert result.freq == freq_sample
diff --git a/pandas/tests/indexes/datetimes/test_reindex.py b/pandas/tests/indexes/datetimes/test_reindex.py
index e4911aa3c4a29..6bc445e8c69a3 100644
--- a/pandas/tests/indexes/datetimes/test_reindex.py
+++ b/pandas/tests/indexes/datetimes/test_reindex.py
@@ -12,14 +12,14 @@
 class TestDatetimeIndexReindex:
     def test_reindex_preserves_tz_if_target_is_empty_list_or_array(self):
         # GH#7774
-        index = date_range("2013-01-01", periods=3, tz="US/Eastern")
+        index = date_range("2013-01-01", periods=3, tz="US/Eastern", unit="ns")
         assert str(index.reindex([])[0].tz) == "US/Eastern"
         assert str(index.reindex(np.array([]))[0].tz) == "US/Eastern"
 
     def test_reindex_with_same_tz_nearest(self):
         # GH#32740
-        rng_a = date_range("2010-01-01", "2010-01-02", periods=24, tz="utc")
-        rng_b = date_range("2010-01-01", "2010-01-02", periods=23, tz="utc")
+        rng_a = date_range("2010-01-01", "2010-01-02", periods=24, tz="utc", unit="ns")
+        rng_b = date_range("2010-01-01", "2010-01-02", periods=23, tz="utc", unit="ns")
         result1, result2 = rng_a.reindex(
             rng_b, method="nearest", tolerance=timedelta(seconds=20)
         )
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index eb472b099fb1f..0d054b985e50f 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -229,7 +229,9 @@ def test_dti_week(self):
     @pytest.mark.parametrize("tz", [None, "US/Eastern"])
     def test_dti_fields(self, tz):
         # GH#13303
-        dti = date_range(freq="D", start=datetime(1998, 1, 1), periods=365, tz=tz)
+        dti = date_range(
+            freq="D", start=datetime(1998, 1, 1), periods=365, tz=tz, unit="ns"
+        )
         assert dti.year[0] == 1998
         assert dti.month[0] == 1
         assert dti.day[0] == 1
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 7a68cb867c94e..38dc96b3cf592 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -62,19 +62,19 @@ def test_union3(self, sort, box):
 
     @pytest.mark.parametrize("tz", tz)
     def test_union(self, tz, sort):
-        rng1 = date_range("1/1/2000", freq="D", periods=5, tz=tz)
-        other1 = date_range("1/6/2000", freq="D", periods=5, tz=tz)
-        expected1 = date_range("1/1/2000", freq="D", periods=10, tz=tz)
+        rng1 = date_range("1/1/2000", freq="D", periods=5, tz=tz, unit="ns")
+        other1 = date_range("1/6/2000", freq="D", periods=5, tz=tz, unit="ns")
+        expected1 = date_range("1/1/2000", freq="D", periods=10, tz=tz, unit="ns")
         expected1_notsorted = DatetimeIndex(list(other1) + list(rng1))
 
-        rng2 = date_range("1/1/2000", freq="D", periods=5, tz=tz)
-        other2 = date_range("1/4/2000", freq="D", periods=5, tz=tz)
-        expected2 = date_range("1/1/2000", freq="D", periods=8, tz=tz)
+        rng2 = date_range("1/1/2000", freq="D", periods=5, tz=tz, unit="ns")
+        other2 = date_range("1/4/2000", freq="D", periods=5, tz=tz, unit="ns")
+        expected2 = date_range("1/1/2000", freq="D", periods=8, tz=tz, unit="ns")
         expected2_notsorted = DatetimeIndex(list(other2) + list(rng2[:3]))
 
-        rng3 = date_range("1/1/2000", freq="D", periods=5, tz=tz)
+        rng3 = date_range("1/1/2000", freq="D", periods=5, tz=tz, unit="ns")
         other3 = DatetimeIndex([], tz=tz).as_unit("ns")
-        expected3 = date_range("1/1/2000", freq="D", periods=5, tz=tz)
+        expected3 = date_range("1/1/2000", freq="D", periods=5, tz=tz, unit="ns")
         expected3_notsorted = rng3
 
         for rng, other, exp, exp_notsorted in [
@@ -287,17 +287,17 @@ def test_intersection2(self):
     )
     def test_intersection(self, tz, sort):
         # GH 4690 (with tz)
-        base = date_range("6/1/2000", "6/30/2000", freq="D", name="idx")
+        base = date_range("6/1/2000", "6/30/2000", freq="D", name="idx", unit="ns")
 
         # if target has the same name, it is preserved
-        rng2 = date_range("5/15/2000", "6/20/2000", freq="D", name="idx")
-        expected2 = date_range("6/1/2000", "6/20/2000", freq="D", name="idx")
+        rng2 = date_range("5/15/2000", "6/20/2000", freq="D", name="idx", unit="ns")
+        expected2 = date_range("6/1/2000", "6/20/2000", freq="D", name="idx", unit="ns")
 
         # if target name is different, it will be reset
-        rng3 = date_range("5/15/2000", "6/20/2000", freq="D", name="other")
-        expected3 = date_range("6/1/2000", "6/20/2000", freq="D", name=None)
+        rng3 = date_range("5/15/2000", "6/20/2000", freq="D", name="other", unit="ns")
+        expected3 = date_range("6/1/2000", "6/20/2000", freq="D", name=None, unit="ns")
 
-        rng4 = date_range("7/1/2000", "7/31/2000", freq="D", name="idx")
+        rng4 = date_range("7/1/2000", "7/31/2000", freq="D", name="idx", unit="ns")
         expected4 = DatetimeIndex([], freq="D", name="idx", dtype="M8[ns]")
 
         for rng, expected in [
@@ -331,7 +331,9 @@ def test_intersection(self, tz, sort):
         ).as_unit("ns")
 
         # GH 7880
-        rng4 = date_range("7/1/2000", "7/31/2000", freq="D", tz=tz, name="idx")
+        rng4 = date_range(
+            "7/1/2000", "7/31/2000", freq="D", tz=tz, unit="ns", name="idx"
+        )
         expected4 = DatetimeIndex([], tz=tz, name="idx").as_unit("ns")
         assert expected4.freq is None
 
@@ -415,8 +417,8 @@ def test_difference(self, tz, sort):
     def test_difference_freq(self, sort):
         # GH14323: difference of DatetimeIndex should not preserve frequency
 
-        index = date_range("20160920", "20160925", freq="D")
-        other = date_range("20160921", "20160924", freq="D")
+        index = date_range("20160920", "20160925", freq="D", unit="ns")
+        other = date_range("20160921", "20160924", freq="D", unit="ns")
         expected = DatetimeIndex(["20160920", "20160925"], dtype="M8[ns]", freq=None)
         idx_diff = index.difference(other, sort)
         tm.assert_index_equal(idx_diff, expected)
@@ -424,7 +426,7 @@ def test_difference_freq(self, sort):
 
         # preserve frequency when the difference is a contiguous
         # subset of the original range
-        other = date_range("20160922", "20160925", freq="D")
+        other = date_range("20160922", "20160925", freq="D", unit="ns")
         idx_diff = index.difference(other, sort)
         expected = DatetimeIndex(["20160920", "20160921"], dtype="M8[ns]", freq="D")
         tm.assert_index_equal(idx_diff, expected)
@@ -589,7 +591,7 @@ def test_union_not_cacheable(self, sort):
         tm.assert_index_equal(the_union, expected)
 
     def test_intersection(self):
-        rng = date_range("1/1/2000", periods=50, freq=Minute())
+        rng = date_range("1/1/2000", periods=50, freq=Minute(), unit="ns")
         rng1 = rng[10:]
         rng2 = rng[:25]
         the_int = rng1.intersection(rng2)
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 8d9340818b511..897b12d4686f5 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -76,7 +76,7 @@ def test_drop_dst_boundary(self):
 
         start = Timestamp("201710290100", tz=tz)
         end = Timestamp("201710290300", tz=tz)
-        index = date_range(start=start, end=end, freq=freq)
+        index = date_range(start=start, end=end, freq=freq, unit="ns")
 
         expected = DatetimeIndex(
             [
diff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py
index ed6c0871aae99..84de11e9dad2f 100644
--- a/pandas/tests/indexes/interval/test_astype.py
+++ b/pandas/tests/indexes/interval/test_astype.py
@@ -221,7 +221,8 @@ def test_subtype_integer(self, index, subtype):
 
         if subtype != "int64":
             msg = (
-                r"Cannot convert interval\[(timedelta64|datetime64)\[ns.*\], .*\] "
+                r"Cannot convert interval"
+                r"\[(timedelta64\[ns\]|datetime64\[us(, US/Eastern)?\]), .*\] "
                 r"to interval\[uint64, .*\]"
             )
             with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 90423149658ab..7a7ac3ae59014 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -40,9 +40,9 @@ class ConstructorTests:
             (Index(np.arange(-10, 11, dtype=np.int64)), np.int64),
             (Index(np.arange(10, 31, dtype=np.uint64)), np.uint64),
             (Index(np.arange(20, 30, 0.5), dtype=np.float64), np.float64),
-            (date_range("20180101", periods=10), "M8[ns]"),
+            (date_range("20180101", periods=10, unit="ns"), "M8[ns]"),
             (
-                date_range("20180101", periods=10, tz="US/Eastern"),
+                date_range("20180101", periods=10, tz="US/Eastern", unit="ns"),
                 "datetime64[ns, US/Eastern]",
             ),
             (timedelta_range("1 day", periods=10), "m8[ns]"),
@@ -69,7 +69,7 @@ def test_constructor(self, constructor, breaks_and_expected_subtype, closed, nam
             (Index([0, 1, 2, 3, 4], dtype=np.int64), "datetime64[ns]"),
             (Index([0, 1, 2, 3, 4], dtype=np.int64), "timedelta64[ns]"),
             (Index([0, 1, 2, 3, 4], dtype=np.float64), "int64"),
-            (date_range("2017-01-01", periods=5), "int64"),
+            (date_range("2017-01-01", periods=5, unit="ns"), "int64"),
             (timedelta_range("1 day", periods=5), "int64"),
         ],
     )
@@ -90,7 +90,7 @@ def test_constructor_dtype(self, constructor, breaks, subtype):
             Index([0, 1, 2, 3, 4], dtype=np.int64),
             Index([0, 1, 2, 3, 4], dtype=np.uint64),
             Index([0, 1, 2, 3, 4], dtype=np.float64),
-            date_range("2017-01-01", periods=5),
+            date_range("2017-01-01", periods=5, unit="ns"),
             timedelta_range("1 day", periods=5),
         ],
     )
@@ -486,7 +486,7 @@ def test_index_mixed_closed(self):
 @pytest.mark.parametrize("timezone", ["UTC", "US/Pacific", "GMT"])
 def test_interval_index_subtype(timezone, inclusive_endpoints_fixture):
     # GH#46999
-    dates = date_range("2022", periods=3, tz=timezone)
+    dates = date_range("2022", periods=3, tz=timezone, unit="ns")
     dtype = f"interval[datetime64[ns, {timezone}], {inclusive_endpoints_fixture}]"
     result = IntervalIndex.from_arrays(
         ["2022-01-01", "2022-01-02"],
diff --git a/pandas/tests/indexes/interval/test_indexing.py b/pandas/tests/indexes/interval/test_indexing.py
index 79700d09a9c23..883151e7c38d2 100644
--- a/pandas/tests/indexes/interval/test_indexing.py
+++ b/pandas/tests/indexes/interval/test_indexing.py
@@ -364,7 +364,7 @@ def test_get_indexer_categorical_with_nans(self):
         tm.assert_numpy_array_equal(result, expected)
 
     def test_get_indexer_datetime(self):
-        ii = IntervalIndex.from_breaks(date_range("2018-01-01", periods=4))
+        ii = IntervalIndex.from_breaks(date_range("2018-01-01", periods=4, unit="ns"))
         # TODO: with mismatched resolution get_indexer currently raises;
         #  this should probably coerce?
         target = DatetimeIndex(["2018-01-02"], dtype="M8[ns]")
@@ -661,7 +661,7 @@ def test_putmask_dt64(self, tz):
 
     def test_putmask_td64(self):
         # GH#37968
-        dti = date_range("2016-01-01", periods=9)
+        dti = date_range("2016-01-01", periods=9, unit="ns")
         tdi = dti - dti[0]
         idx = IntervalIndex.from_breaks(tdi)
         mask = np.zeros(idx.shape, dtype=bool)
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index b302e865eebd1..e8055480e3968 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -81,7 +81,7 @@ 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],
-            date_range("2017-01-01", "2017-01-04"),
+            date_range("2017-01-01", "2017-01-04", unit="ns"),
             pytest.param(
                 date_range("2017-01-01", "2017-01-04", unit="s"),
                 marks=pytest.mark.xfail(reason="mismatched result unit"),
@@ -377,13 +377,16 @@ def test_maybe_convert_i8(self, breaks):
 
     @pytest.mark.parametrize(
         "breaks",
-        [date_range("2018-01-01", periods=5), timedelta_range("0 days", periods=5)],
+        [
+            date_range("2018-01-01", periods=5),
+            timedelta_range("0 days", periods=5, unit="us"),
+        ],
     )
     def test_maybe_convert_i8_nat(self, breaks):
         # GH 20636
         index = IntervalIndex.from_breaks(breaks)
 
-        to_convert = breaks._constructor([pd.NaT] * 3).as_unit("ns")
+        to_convert = breaks._constructor([pd.NaT] * 3).as_unit("us")
         expected = Index([np.nan] * 3, dtype=np.float64)
         result = index._maybe_convert_i8(to_convert)
         tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py
index 66c0111edb16e..dbb01b28d23fb 100644
--- a/pandas/tests/indexes/interval/test_interval_range.py
+++ b/pandas/tests/indexes/interval/test_interval_range.py
@@ -265,7 +265,7 @@ def test_constructor_coverage(self):
             tm.assert_index_equal(result, expected)
 
         # equivalent timedelta-like start/end
-        start, end = Timedelta(days=1), Timedelta(days=10)
+        start, end = Timedelta(days=1).as_unit("us"), Timedelta(days=10).as_unit("us")
         expected = interval_range(start=start, end=end)
 
         result = interval_range(start=start.to_pytimedelta(), end=end.to_pytimedelta())
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index c3cae18bcf83b..b794a49b5f85f 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -35,7 +35,11 @@ def test_get_level_number_integer(idx):
 def test_get_dtypes(using_infer_string):
     # Test MultiIndex.dtypes (# Gh37062)
     idx_multitype = MultiIndex.from_product(
-        [[1, 2, 3], ["a", "b", "c"], pd.date_range("20200101", periods=2, tz="UTC")],
+        [
+            [1, 2, 3],
+            ["a", "b", "c"],
+            pd.date_range("20200101", periods=2, tz="UTC", unit="ns"),
+        ],
         names=["int", "string", "dt"],
     )
 
@@ -56,7 +60,7 @@ def test_get_dtypes_no_level_name(using_infer_string):
         [
             [1, 2, 3],
             ["a", "b", "c"],
-            pd.date_range("20200101", periods=2, tz="UTC"),
+            pd.date_range("20200101", periods=2, tz="UTC", unit="ns"),
         ],
     )
     exp = "object" if not using_infer_string else pd.StringDtype(na_value=np.nan)
@@ -76,7 +80,7 @@ def test_get_dtypes_duplicate_level_names(using_infer_string):
         [
             [1, 2, 3],
             ["a", "b", "c"],
-            pd.date_range("20200101", periods=2, tz="UTC"),
+            pd.date_range("20200101", periods=2, tz="UTC", unit="ns"),
         ],
         names=["A", "A", "A"],
     ).dtypes
diff --git a/pandas/tests/indexes/period/methods/test_to_timestamp.py b/pandas/tests/indexes/period/methods/test_to_timestamp.py
index 4fe429ce71ee4..463e40862c44f 100644
--- a/pandas/tests/indexes/period/methods/test_to_timestamp.py
+++ b/pandas/tests/indexes/period/methods/test_to_timestamp.py
@@ -18,7 +18,7 @@
 class TestToTimestamp:
     def test_to_timestamp_non_contiguous(self):
         # GH#44100
-        dti = date_range("2021-10-18", periods=9, freq="D")
+        dti = date_range("2021-10-18", periods=9, freq="D", unit="ns")
         pi = dti.to_period()
 
         result = pi[::2].to_timestamp()
@@ -49,7 +49,7 @@ def test_to_timestamp_non_contiguous(self):
     def test_to_timestamp_freq(self):
         idx = period_range("2017", periods=12, freq="Y-DEC")
         result = idx.to_timestamp()
-        expected = date_range("2017", periods=12, freq="YS-JAN")
+        expected = date_range("2017", periods=12, freq="YS-JAN", unit="ns")
         tm.assert_index_equal(result, expected)
 
     def test_to_timestamp_pi_nat(self):
diff --git a/pandas/tests/indexes/period/test_scalar_compat.py b/pandas/tests/indexes/period/test_scalar_compat.py
index d8afd29ff31c5..92bfe122a8a9a 100644
--- a/pandas/tests/indexes/period/test_scalar_compat.py
+++ b/pandas/tests/indexes/period/test_scalar_compat.py
@@ -14,7 +14,9 @@ class TestPeriodIndexOps:
     def test_start_time(self):
         # GH#17157
         index = period_range(freq="M", start="2016-01-01", end="2016-05-31")
-        expected_index = date_range("2016-01-01", end="2016-05-31", freq="MS")
+        expected_index = date_range(
+            "2016-01-01", end="2016-05-31", freq="MS", unit="ns"
+        )
         tm.assert_index_equal(index.start_time, expected_index)
 
     def test_end_time(self):
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 26eb33195ccbc..2a80c692d17bf 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -220,7 +220,7 @@ def test_constructor_dtypes_datetime(self, tz_naive_fixture, attr, klass):
         # .asi8 produces integers, so these are considered epoch timestamps
         # ^the above will be true in a later version. Right now we `.view`
         # the i8 values as NS_DTYPE, effectively treating them as wall times.
-        index = date_range("2011-01-01", periods=5)
+        index = date_range("2011-01-01", periods=5, unit="ns")
         arg = getattr(index, attr)
         index = index.tz_localize(tz_naive_fixture)
         dtype = index.dtype
diff --git a/pandas/tests/indexing/multiindex/test_partial.py b/pandas/tests/indexing/multiindex/test_partial.py
index dbfabf7666d25..6b3c4e8ac2989 100644
--- a/pandas/tests/indexing/multiindex/test_partial.py
+++ b/pandas/tests/indexing/multiindex/test_partial.py
@@ -208,14 +208,14 @@ def test_setitem_multiple_partial(self, multiindex_dataframe_random_data):
             ),
             (
                 slice(None, "2019-2"),
-                date_range("2019", periods=2, freq="MS"),
+                date_range("2019", periods=2, freq="MS", unit="ns"),
                 [0, 1, 2, 3],
             ),
         ],
     )
     def test_partial_getitem_loc_datetime(self, indexer, exp_idx, exp_values):
         # GH: 25165
-        date_idx = date_range("2019", periods=2, freq="MS")
+        date_idx = date_range("2019", periods=2, freq="MS", unit="ns")
         df = DataFrame(
             list(range(4)),
             index=MultiIndex.from_product([date_idx, [0, 1]], names=["x", "y"]),
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index eedcc6d4e8819..e0174a6613615 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -439,7 +439,9 @@ def test_where_series_bool(self, index_or_series, fill_val, exp_dtype):
     def test_where_datetime64(self, index_or_series, fill_val, exp_dtype):
         klass = index_or_series
 
-        obj = klass(pd.date_range("2011-01-01", periods=4, freq="D")._with_freq(None))
+        obj = klass(
+            pd.date_range("2011-01-01", periods=4, freq="D", unit="ns")._with_freq(None)
+        )
         assert obj.dtype == "datetime64[ns]"
 
         fv = fill_val
diff --git a/pandas/tests/indexing/test_datetime.py b/pandas/tests/indexing/test_datetime.py
index af7533399ea74..a890de3b977ea 100644
--- a/pandas/tests/indexing/test_datetime.py
+++ b/pandas/tests/indexing/test_datetime.py
@@ -54,7 +54,7 @@ def test_indexing_with_datetime_tz(self):
 
     def test_indexing_fast_xs(self):
         # indexing - fast_xs
-        df = DataFrame({"a": date_range("2014-01-01", periods=10, tz="UTC")})
+        df = DataFrame({"a": date_range("2014-01-01", periods=10, tz="UTC", unit="ns")})
         result = df.iloc[5]
         expected = Series(
             [Timestamp("2014-01-06 00:00:00+0000", tz="UTC")],
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 1877746aa9c97..4dc6f38c7410c 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -868,7 +868,7 @@ def test_loc_setitem_frame_multiples(self):
         # multiple setting with frame on rhs (with M8)
         df = DataFrame(
             {
-                "date": date_range("2000-01-01", "2000-01-5"),
+                "date": date_range("2000-01-01", "2000-01-5", unit="ns"),
                 "val": Series(range(5), dtype=np.int64),
             }
         )
@@ -1844,7 +1844,7 @@ def test_loc_getitem_datetime_string_with_datetimeindex(self):
         # GH 16710
         df = DataFrame(
             {"a": range(10), "b": range(10)},
-            index=date_range("2010-01-01", "2010-01-10"),
+            index=date_range("2010-01-01", "2010-01-10", unit="ns"),
         )
         result = df.loc[["2010-01-01", "2010-01-05"], ["a", "b"]]
         expected = DataFrame(
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index e4d5eb4758303..bec53a0450b68 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -689,7 +689,11 @@ class TestTableOrientReader:
             {"ints": [1, 2, 3, 4]},
             {"objects": ["a", "b", "c", "d"]},
             {"objects": ["1", "2", "3", "4"]},
-            {"date_ranges": pd.date_range("2016-01-01", freq="D", periods=4)},
+            {
+                "date_ranges": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, unit="ns"
+                )
+            },
             {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
             {
                 "ordered_cats": pd.Series(
@@ -701,7 +705,7 @@ class TestTableOrientReader:
             {"bools": [True, False, False, True]},
             {
                 "timezones": pd.date_range(
-                    "2016-01-01", freq="D", periods=4, tz="US/Central"
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
                 )  # added in # GH 35973
             },
         ],
@@ -740,7 +744,11 @@ def test_read_json_table_orient_raises(self, index_nm):
             {"ints": [1, 2, 3, 4]},
             {"objects": ["a", "b", "c", "d"]},
             {"objects": ["1", "2", "3", "4"]},
-            {"date_ranges": pd.date_range("2016-01-01", freq="D", periods=4)},
+            {
+                "date_ranges": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, unit="ns"
+                )
+            },
             {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
             {
                 "ordered_cats": pd.Series(
@@ -752,7 +760,7 @@ def test_read_json_table_orient_raises(self, index_nm):
             {"bools": [True, False, False, True]},
             {
                 "timezones": pd.date_range(
-                    "2016-01-01", freq="D", periods=4, tz="US/Central"
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
                 )  # added in # GH 35973
             },
         ],
@@ -776,13 +784,16 @@ def test_read_json_table_period_orient(self, index_nm, vals):
                 "2020-08-30",
                 freq="D",
                 periods=4,
+                unit="ns",
             )._with_freq(None),
             pd.date_range(
-                "2020-08-30", freq="D", periods=4, tz="US/Central"
+                "2020-08-30", freq="D", periods=4, tz="US/Central", unit="ns"
             )._with_freq(None),
             pd.MultiIndex.from_product(
                 [
-                    pd.date_range("2020-08-30", freq="D", periods=2, tz="US/Central"),
+                    pd.date_range(
+                        "2020-08-30", freq="D", periods=2, tz="US/Central", unit="ns"
+                    ),
                     ["x", "y"],
                 ],
             ),
@@ -792,10 +803,10 @@ def test_read_json_table_period_orient(self, index_nm, vals):
         "vals",
         [
             {"floats": [1.1, 2.2, 3.3, 4.4]},
-            {"dates": pd.date_range("2020-08-30", freq="D", periods=4)},
+            {"dates": pd.date_range("2020-08-30", freq="D", periods=4, unit="ns")},
             {
                 "timezones": pd.date_range(
-                    "2020-08-30", freq="D", periods=4, tz="Europe/London"
+                    "2020-08-30", freq="D", periods=4, tz="Europe/London", unit="ns"
                 )
             },
         ],
@@ -812,12 +823,14 @@ def test_comprehensive(self):
             {
                 "A": [1, 2, 3, 4],
                 "B": ["a", "b", "c", "c"],
-                "C": pd.date_range("2016-01-01", freq="D", periods=4),
+                "C": pd.date_range("2016-01-01", freq="D", periods=4, unit="ns"),
                 # 'D': pd.timedelta_range('1h', periods=4, freq='min'),
                 "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
                 "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
                 "G": [1.1, 2.2, 3.3, 4.4],
-                "H": pd.date_range("2016-01-01", freq="D", periods=4, tz="US/Central"),
+                "H": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
+                ),
                 "I": [True, False, False, True],
             },
             index=pd.Index(range(4), name="idx"),
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 44ba18c2cd183..e71feb0100ade 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -75,7 +75,7 @@ def datetime_series(self):
         #  since that doesn't round-trip, see GH#33711
         ser = Series(
             1.1 * np.arange(10, dtype=np.float64),
-            index=date_range("2020-01-01", periods=10),
+            index=date_range("2020-01-01", periods=10, unit="ns"),
             name="ts",
         )
         ser.index = ser.index._with_freq(None)
@@ -88,7 +88,7 @@ def datetime_frame(self):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((30, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=30, freq="B"),
+            index=date_range("2000-01-01", periods=30, freq="B", unit="ns"),
         )
         df.index = df.index._with_freq(None)
         return df
@@ -495,7 +495,7 @@ def test_frame_mixedtype_orient(self):  # GH10289
         tm.assert_frame_equal(left, right)
 
     def test_v12_compat(self, datapath):
-        dti = date_range("2000-01-03", "2000-01-07")
+        dti = date_range("2000-01-03", "2000-01-07", unit="ns")
         # freq doesn't roundtrip
         dti = DatetimeIndex(np.asarray(dti), freq=None)
         df = DataFrame(
@@ -525,7 +525,7 @@ def test_v12_compat(self, datapath):
         tm.assert_frame_equal(df_iso, df_unser_iso, check_column_type=False)
 
     def test_blocks_compat_GH9037(self, using_infer_string):
-        index = date_range("20000101", periods=10, freq="h")
+        index = date_range("20000101", periods=10, freq="h", unit="ns")
         # freq doesn't round-trip
         index = DatetimeIndex(list(index), freq=None)
 
@@ -1093,7 +1093,7 @@ def test_doc_example(self):
         dfj2["date"] = Timestamp("20130101")
         dfj2["ints"] = range(5)
         dfj2["bools"] = True
-        dfj2.index = date_range("20130101", periods=5)
+        dfj2.index = date_range("20130101", periods=5, unit="ns")
 
         msg = (
             "The default 'epoch' date format is deprecated and will be removed "
@@ -1163,7 +1163,7 @@ def test_timedelta2(self):
             {
                 "a": [timedelta(days=23), timedelta(seconds=5)],
                 "b": [1, 2],
-                "c": date_range(start="20130101", periods=2),
+                "c": date_range(start="20130101", periods=2, unit="ns"),
             }
         )
         msg = (
@@ -1307,10 +1307,12 @@ def test_categorical(self):
 
     def test_datetime_tz(self):
         # GH4377 df.to_json segfaults with non-ndarray blocks
-        tz_range = date_range("20130101", periods=3, tz="US/Eastern")
+        tz_range = date_range("20130101", periods=3, tz="US/Eastern", unit="ns")
         tz_naive = tz_range.tz_convert("utc").tz_localize(None)
 
-        df = DataFrame({"A": tz_range, "B": date_range("20130101", periods=3)})
+        df = DataFrame(
+            {"A": tz_range, "B": date_range("20130101", periods=3, unit="ns")}
+        )
 
         df_naive = df.copy()
         df_naive["A"] = tz_naive
@@ -1369,9 +1371,9 @@ def test_tz_is_naive(self):
     @pytest.mark.parametrize(
         "tz_range",
         [
-            date_range("2013-01-01 05:00:00Z", periods=2),
-            date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern"),
-            date_range("2013-01-01 00:00:00-0500", periods=2),
+            date_range("2013-01-01 05:00:00Z", periods=2, unit="ns"),
+            date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern", unit="ns"),
+            date_range("2013-01-01 00:00:00-0500", periods=2, unit="ns"),
         ],
     )
     def test_tz_range_is_utc(self, tz_range):
@@ -1390,7 +1392,7 @@ def test_tz_range_is_utc(self, tz_range):
         assert ujson_dumps(df.astype({"DT": object}), iso_dates=True)
 
     def test_tz_range_is_naive(self):
-        dti = date_range("2013-01-01 05:00:00", periods=2)
+        dti = date_range("2013-01-01 05:00:00", periods=2, unit="ns")
 
         exp = '["2013-01-01T05:00:00.000","2013-01-02T05:00:00.000"]'
         dfexp = '{"DT":{"0":"2013-01-01T05:00:00.000","1":"2013-01-02T05:00:00.000"}}'
@@ -2047,7 +2049,7 @@ def test_to_json_multiindex_escape(self):
         # GH 15273
         df = DataFrame(
             True,
-            index=date_range("2017-01-20", "2017-01-23"),
+            index=date_range("2017-01-20", "2017-01-23", unit="ns"),
             columns=["foo", "bar"],
         ).stack()
         result = df.to_json()
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index d2bf9bdb139bd..9470841c87abb 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -917,7 +917,9 @@ def test_datetime_index(self):
         date_unit = "ns"
 
         # freq doesn't round-trip
-        rng = DatetimeIndex(list(date_range("1/1/2000", periods=20)), freq=None)
+        rng = DatetimeIndex(
+            list(date_range("1/1/2000", periods=20, unit="ns")), freq=None
+        )
         encoded = ujson.ujson_dumps(rng, date_unit=date_unit)
 
         decoded = DatetimeIndex(np.array(ujson.ujson_loads(encoded)))
diff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py
index 308fae487f842..940ae1e7f7db3 100644
--- a/pandas/tests/io/pytables/test_append.py
+++ b/pandas/tests/io/pytables/test_append.py
@@ -519,7 +519,7 @@ def test_append_with_data_columns(setup_path):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         df.iloc[0, df.columns.get_loc("B")] = 1.0
         _maybe_remove(store, "df")
diff --git a/pandas/tests/io/pytables/test_errors.py b/pandas/tests/io/pytables/test_errors.py
index 37e6eeb05deec..40c94e7909e09 100644
--- a/pandas/tests/io/pytables/test_errors.py
+++ b/pandas/tests/io/pytables/test_errors.py
@@ -49,7 +49,9 @@ def test_pass_spec_to_storer(setup_path):
 
 def test_table_index_incompatible_dtypes(setup_path):
     df1 = DataFrame({"a": [1, 2, 3]})
-    df2 = DataFrame({"a": [4, 5, 6]}, index=date_range("1/1/2000", periods=3))
+    df2 = DataFrame(
+        {"a": [4, 5, 6]}, index=date_range("1/1/2000", periods=3, unit="ns")
+    )
 
     with ensure_clean_store(setup_path) as store:
         store.put("frame", df1, format="table")
@@ -105,7 +107,7 @@ def test_invalid_terms(tmp_path, setup_path):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD"), dtype=object),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         df["string"] = "foo"
         df.loc[df.index[0:4], "string"] = "bar"
@@ -134,7 +136,7 @@ def test_invalid_terms(tmp_path, setup_path):
     dfq = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=list("ABCD"),
-        index=date_range("20130101", periods=10),
+        index=date_range("20130101", periods=10, unit="ns"),
     )
     dfq.to_hdf(path, key="dfq", format="table", data_columns=True)
 
@@ -147,7 +149,7 @@ def test_invalid_terms(tmp_path, setup_path):
     dfq = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=list("ABCD"),
-        index=date_range("20130101", periods=10),
+        index=date_range("20130101", periods=10, unit="ns"),
     )
     dfq.to_hdf(path, key="dfq", format="table")
 
@@ -196,7 +198,7 @@ def test_invalid_complib(tmp_path, setup_path):
 @pytest.mark.parametrize(
     "idx",
     [
-        date_range("2019", freq="D", periods=3, tz="UTC"),
+        date_range("2019", freq="D", periods=3, tz="UTC", unit="ns"),
         CategoricalIndex(list("abc")),
     ],
 )
diff --git a/pandas/tests/io/pytables/test_select.py b/pandas/tests/io/pytables/test_select.py
index 0dffb284fa6d2..df76382149621 100644
--- a/pandas/tests/io/pytables/test_select.py
+++ b/pandas/tests/io/pytables/test_select.py
@@ -65,7 +65,7 @@ def test_select_with_dups(setup_path):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)), columns=["A", "A", "B", "B"]
     )
-    df.index = date_range("20130101 9:30", periods=10, freq="min")
+    df.index = date_range("20130101 9:30", periods=10, freq="min", unit="ns")
 
     with ensure_clean_store(setup_path) as store:
         store.append("df", df)
@@ -96,7 +96,7 @@ def test_select_with_dups(setup_path):
         ],
         axis=1,
     )
-    df.index = date_range("20130101 9:30", periods=10, freq="min")
+    df.index = date_range("20130101 9:30", periods=10, freq="min", unit="ns")
 
     with ensure_clean_store(setup_path) as store:
         store.append("df", df)
@@ -134,7 +134,7 @@ def test_select(setup_path):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", df)
@@ -174,7 +174,7 @@ def test_select_dtypes(setup_path, request):
         # with a Timestamp data column (GH #2637)
         df = DataFrame(
             {
-                "ts": bdate_range("2012-01-01", periods=300),
+                "ts": bdate_range("2012-01-01", periods=300, unit="ns"),
                 "A": np.random.default_rng(2).standard_normal(300),
             }
         )
@@ -296,7 +296,7 @@ def test_select_with_many_inputs(setup_path):
     with ensure_clean_store(setup_path) as store:
         df = DataFrame(
             {
-                "ts": bdate_range("2012-01-01", periods=300),
+                "ts": bdate_range("2012-01-01", periods=300, unit="ns"),
                 "A": np.random.default_rng(2).standard_normal(300),
                 "B": range(300),
                 "users": ["a"] * 50
@@ -346,7 +346,7 @@ def test_select_iterator(tmp_path, setup_path):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", df)
@@ -371,7 +371,7 @@ def test_select_iterator(tmp_path, setup_path):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
     df.to_hdf(path, key="df_non_table")
 
@@ -387,7 +387,7 @@ def test_select_iterator(tmp_path, setup_path):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
     df.to_hdf(path, key="df", format="table")
 
@@ -404,7 +404,7 @@ def test_select_iterator(tmp_path, setup_path):
         df1 = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         store.append("df1", df1, data_columns=True)
         df2 = df1.copy().rename(columns="{}_2".format)
@@ -432,7 +432,7 @@ def test_select_iterator_complete_8014(setup_path):
         expected = DataFrame(
             np.random.default_rng(2).standard_normal((100064, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=100064, freq="s"),
+            index=date_range("2000-01-01", periods=100064, freq="s", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", expected)
@@ -467,7 +467,7 @@ def test_select_iterator_complete_8014(setup_path):
         expected = DataFrame(
             np.random.default_rng(2).standard_normal((100064, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=100064, freq="s"),
+            index=date_range("2000-01-01", periods=100064, freq="s", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", expected)
@@ -509,7 +509,7 @@ def test_select_iterator_non_complete_8014(setup_path):
         expected = DataFrame(
             np.random.default_rng(2).standard_normal((100064, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=100064, freq="s"),
+            index=date_range("2000-01-01", periods=100064, freq="s", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", expected)
@@ -543,7 +543,7 @@ def test_select_iterator_non_complete_8014(setup_path):
         expected = DataFrame(
             np.random.default_rng(2).standard_normal((100064, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=100064, freq="s"),
+            index=date_range("2000-01-01", periods=100064, freq="s", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", expected)
@@ -567,7 +567,7 @@ def test_select_iterator_many_empty_frames(setup_path):
         expected = DataFrame(
             np.random.default_rng(2).standard_normal((100064, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=100064, freq="s"),
+            index=date_range("2000-01-01", periods=100064, freq="s", unit="ns"),
         )
         _maybe_remove(store, "df")
         store.append("df", expected)
@@ -619,7 +619,7 @@ def test_frame_select(setup_path, request):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
 
     with ensure_clean_store(setup_path) as store:
@@ -651,7 +651,7 @@ def test_frame_select(setup_path, request):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
         store.append("df_time", df)
         msg = "day is out of range for month: 0"
@@ -670,7 +670,7 @@ def test_frame_select_complex(setup_path):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
     df["string"] = "foo"
     df.loc[df.index[0:4], "string"] = "bar"
@@ -787,7 +787,7 @@ def test_invalid_filtering(setup_path):
     df = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
 
     with ensure_clean_store(setup_path) as store:
@@ -809,7 +809,7 @@ def test_string_select(setup_path):
         df = DataFrame(
             np.random.default_rng(2).standard_normal((10, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=10, freq="B"),
+            index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
         )
 
         # test string ==/!=
@@ -853,7 +853,7 @@ def test_select_as_multiple(setup_path):
     df1 = DataFrame(
         np.random.default_rng(2).standard_normal((10, 4)),
         columns=Index(list("ABCD")),
-        index=date_range("2000-01-01", periods=10, freq="B"),
+        index=date_range("2000-01-01", periods=10, freq="B", unit="ns"),
     )
     df2 = df1.copy().rename(columns="{}_2".format)
     df2["foo"] = "bar"
@@ -982,7 +982,7 @@ def test_query_compare_column_type(setup_path):
     df = DataFrame(
         {
             "date": ["2014-01-01", "2014-01-02"],
-            "real_date": date_range("2014-01-01", periods=2),
+            "real_date": date_range("2014-01-01", periods=2, unit="ns"),
             "float": [1.1, 1.2],
             "int": [1, 2],
         },
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 688fedb55ca5a..a80c7ea59c2b7 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -587,7 +587,7 @@ def test_same_name_scoping(setup_path):
     with ensure_clean_store(setup_path) as store:
         df = DataFrame(
             np.random.default_rng(2).standard_normal((20, 2)),
-            index=date_range("20130101", periods=20),
+            index=date_range("20130101", periods=20, unit="ns"),
         )
         store.put("df", df, format="table")
         expected = df[df.index > Timestamp("20130105")]
diff --git a/pandas/tests/io/pytables/test_timezones.py b/pandas/tests/io/pytables/test_timezones.py
index f9411cd22896a..d660c91407cf9 100644
--- a/pandas/tests/io/pytables/test_timezones.py
+++ b/pandas/tests/io/pytables/test_timezones.py
@@ -358,7 +358,7 @@ def test_dst_transitions(tmp_path):
 def test_read_with_where_tz_aware_index(tmp_path, setup_path):
     # GH 11926
     periods = 10
-    dts = date_range("20151201", periods=periods, freq="D", tz="UTC")
+    dts = date_range("20151201", periods=periods, freq="D", tz="UTC", unit="ns")
     mi = pd.MultiIndex.from_arrays([dts, range(periods)], names=["DATE", "NO"])
     expected = DataFrame({"MYCOL": 0}, index=mi)
 
diff --git a/pandas/tests/io/test_gcs.py b/pandas/tests/io/test_gcs.py
index ad58fccbf4102..7a309ed632970 100644
--- a/pandas/tests/io/test_gcs.py
+++ b/pandas/tests/io/test_gcs.py
@@ -67,7 +67,7 @@ def test_to_read_gcs(gcs_buffer, format, monkeypatch, capsys, request):
             "int": [1, 3],
             "float": [2.0, np.nan],
             "str": ["t", "s"],
-            "dt": date_range("2018-06-18", periods=2),
+            "dt": date_range("2018-06-18", periods=2, unit="ns"),
         }
     )
 
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index a2a0bf2866d37..76e5e07f680b0 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -311,7 +311,7 @@ def test_orc_dtype_backend_pyarrow(using_infer_string):
             "float_with_nan": [2.0, np.nan, 3.0],
             "bool": [True, False, True],
             "bool_with_na": [True, False, None],
-            "datetime": pd.date_range("20130101", periods=3),
+            "datetime": pd.date_range("20130101", periods=3, unit="ns"),
             "datetime_with_nat": [
                 pd.Timestamp("20130101"),
                 pd.NaT,
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index e450cd76f3ad3..8435eb97080c4 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -138,7 +138,7 @@ def df_full():
             "float": np.arange(4.0, 7.0, dtype="float64"),
             "float_with_nan": [2.0, np.nan, 3.0],
             "bool": [True, False, True],
-            "datetime": pd.date_range("20130101", periods=3),
+            "datetime": pd.date_range("20130101", periods=3, unit="ns"),
             "datetime_with_nat": [
                 pd.Timestamp("20130101"),
                 pd.NaT,
@@ -443,7 +443,7 @@ def test_write_index(self, temp_file):
 
         indexes = [
             [2, 3, 4],
-            pd.date_range("20130101", periods=3),
+            pd.date_range("20130101", periods=3, unit="ns"),
             list("abc"),
             [1, 3, 4],
         ]
@@ -470,7 +470,7 @@ def test_write_multiindex(self, pa, temp_file):
 
     def test_multiindex_with_columns(self, pa, temp_file):
         engine = pa
-        dates = pd.date_range("01-Jan-2018", "01-Dec-2018", freq="MS")
+        dates = pd.date_range("01-Jan-2018", "01-Dec-2018", freq="MS", unit="ns")
         df = pd.DataFrame(
             np.random.default_rng(2).standard_normal((2 * len(dates), 3)),
             columns=list("ABC"),
@@ -1051,7 +1051,7 @@ def test_read_dtype_backend_pyarrow_config(self, pa, df_full, temp_file):
         df = df_full
 
         # additional supported types for pyarrow
-        dti = pd.date_range("20130101", periods=3, tz="Europe/Brussels")
+        dti = pd.date_range("20130101", periods=3, tz="Europe/Brussels", unit="ns")
         dti = dti._with_freq(None)  # freq doesn't round-trip
         df["datetime_tz"] = dti
         df["bool_with_none"] = [True, None, True]
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index 46894fbaa6d5b..ca56185deaebe 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -673,7 +673,7 @@ def test_secondary_both(self):
         assert not hasattr(ax2, "right_ax")
 
     def test_secondary_y_ts(self):
-        idx = date_range("1/1/2000", periods=10)
+        idx = date_range("1/1/2000", periods=10, unit="ns")
         ser = Series(np.random.default_rng(2).standard_normal(10), idx)
         fig, _ = mpl.pyplot.subplots()
         ax = ser.plot(secondary_y=True)
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index db27572b9da26..5b16b1ef21be0 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -37,10 +37,10 @@ def get_objs():
         Index([True, False] * 5, name="a"),
         Index(np.arange(10), dtype=np.int64, name="a"),
         Index(np.arange(10), dtype=np.float64, name="a"),
-        DatetimeIndex(date_range("2020-01-01", periods=10), name="a"),
-        DatetimeIndex(date_range("2020-01-01", periods=10), name="a").tz_localize(
-            tz="US/Eastern"
-        ),
+        DatetimeIndex(date_range("2020-01-01", periods=10, unit="ns"), name="a"),
+        DatetimeIndex(
+            date_range("2020-01-01", periods=10, unit="ns"), name="a"
+        ).tz_localize(tz="US/Eastern"),
         PeriodIndex(period_range("2020-01-01", periods=10, freq="D"), name="a"),
         Index([str(i) for i in range(10)], name="a"),
     ]
@@ -198,7 +198,8 @@ def test_argminmax(self):
     def test_same_tz_min_max_axis_1(self, op, expected_col):
         # GH 10390
         df = DataFrame(
-            date_range("2016-01-01 00:00:00", periods=3, tz="UTC"), columns=["a"]
+            date_range("2016-01-01 00:00:00", periods=3, tz="UTC", unit="ns"),
+            columns=["a"],
         )
         df["b"] = df.a.subtract(Timedelta(seconds=3600))
         result = getattr(df, op)(axis=1)
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index cef50e93b55bc..359ad72bd67f3 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -540,7 +540,7 @@ def test_first_last_skipna(any_real_nullable_dtype, skipna, how):
             "b": [na_value, 3.0, na_value, 4.0],
             "c": [na_value, 3.0, na_value, 4.0],
         },
-        index=date_range("2020-01-01", periods=4, freq="D"),
+        index=date_range("2020-01-01", periods=4, freq="D", unit="ns"),
         dtype=any_real_nullable_dtype,
     )
     rs = df.resample("ME")
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 4c68a25309303..a7f62ff0f6d26 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -2058,7 +2058,7 @@ def test_resample_BM_BQ_raises(freq):
 def test_resample_depr_lowercase_frequency(freq, freq_depr, data):
     msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a future version."
 
-    s = Series(range(5), index=date_range("20130101", freq="h", periods=5))
+    s = Series(range(5), index=date_range("20130101", freq="h", periods=5, unit="ns"))
     with tm.assert_produces_warning(Pandas4Warning, match=msg):
         result = s.resample(freq_depr).mean()
 
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 5cf0446911806..d7e2613b823f7 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -710,7 +710,7 @@ def test_evenly_divisible_with_no_extra_bins(self):
 
         df = DataFrame(
             np.random.default_rng(2).standard_normal((9, 3)),
-            index=date_range("2000-1-1", periods=9),
+            index=date_range("2000-1-1", periods=9, unit="ns"),
         )
         result = df.resample("5D").mean()
         expected = pd.concat([df.iloc[0:5].mean(), df.iloc[5:].mean()], axis=1).T
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 69a20443db344..36ef01178b3bc 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -99,7 +99,7 @@ def test_groupby_resample_on_api():
 
 
 def test_resample_group_keys():
-    df = DataFrame({"A": 1, "B": 2}, index=date_range("2000", periods=10))
+    df = DataFrame({"A": 1, "B": 2}, index=date_range("2000", periods=10, unit="ns"))
     expected = df.copy()
 
     # group_keys=False
@@ -221,7 +221,7 @@ def test_combined_up_downsampling_of_irregular():
     # ts2.resample('2s').mean().ffill()
     # preserve these semantics
 
-    rng = date_range("1/1/2012", periods=100, freq="s")
+    rng = date_range("1/1/2012", periods=100, freq="s", unit="ns")
     ts = Series(np.arange(len(rng)), index=rng)
     ts2 = ts.iloc[[0, 1, 2, 3, 5, 7, 11, 15, 16, 25, 30]]
 
@@ -355,7 +355,7 @@ def test_agg_consistency_int_str_column_mix():
 
 @pytest.fixture
 def index():
-    index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
+    index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D", unit="ns")
     index.name = "date"
     return index
 
@@ -744,7 +744,7 @@ def test_agg_with_datetime_index_list_agg_func(col_name):
 
 def test_resample_agg_readonly():
     # GH#31710 cython needs to allow readonly data
-    index = date_range("2020-01-01", "2020-01-02", freq="1h")
+    index = date_range("2020-01-01", "2020-01-02", freq="1h", unit="ns")
     arr = np.zeros_like(index)
     arr.setflags(write=False)
 
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index f3c52a674cf66..1d319600e632d 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -21,7 +21,7 @@
 def test_frame():
     return DataFrame(
         {"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)},
-        index=date_range("1/1/2000", freq="s", periods=40),
+        index=date_range("1/1/2000", freq="s", periods=40, unit="ns"),
     )
 
 
@@ -178,7 +178,7 @@ def test_groupby_with_origin():
 def test_nearest():
     # GH 17496
     # Resample nearest
-    index = date_range("1/1/2000", periods=3, freq="min")
+    index = date_range("1/1/2000", periods=3, freq="min", unit="ns")
     result = Series(range(3), index=index).resample("20s").nearest()
 
     expected = Series(
@@ -464,7 +464,7 @@ def test_empty(keys):
 def test_resample_groupby_agg_object_dtype_all_nan(consolidate):
     # https://github.com/pandas-dev/pandas/issues/39329
 
-    dates = date_range("2020-01-01", periods=15, freq="D")
+    dates = date_range("2020-01-01", periods=15, freq="D", unit="ns")
     df1 = DataFrame({"key": "A", "date": dates, "col1": range(15), "col_object": "val"})
     df2 = DataFrame({"key": "B", "date": dates, "col1": range(15)})
     df = pd.concat([df1, df2], ignore_index=True)
@@ -586,7 +586,7 @@ def test_groupby_resample_size_all_index_same():
     # GH 46826
     df = DataFrame(
         {"A": [1] * 3 + [2] * 3 + [1] * 3 + [2] * 3, "B": np.arange(12)},
-        index=date_range("31/12/2000 18:00", freq="h", periods=12),
+        index=date_range("31/12/2000 18:00", freq="h", periods=12, unit="ns"),
     )
     result = df.groupby("A").resample("D").size()
 
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index e6cfa12f5f61a..50a44298a15af 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -150,7 +150,9 @@ def test_aggregate_normal(resample_method):
 
     expected = getattr(normal_grouped, resample_method)()
     dt_result = getattr(dt_grouped, resample_method)()
-    expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
+    expected.index = date_range(
+        start="2013-01-01", freq="D", periods=5, unit="ns", name="key"
+    )
     tm.assert_equal(expected, dt_result)
 
 
@@ -192,7 +194,7 @@ def test_aggregate_nth():
     ],
 )
 def test_resample_entirely_nat_window(method, method_args, unit):
-    ser = Series([0] * 2 + [np.nan] * 2, index=date_range("2017", periods=4))
+    ser = Series([0] * 2 + [np.nan] * 2, index=date_range("2017", periods=4, unit="ns"))
     result = methodcaller(method, **method_args)(ser.resample("2D"))
 
     exp_dti = pd.DatetimeIndex(["2017-01-01", "2017-01-03"], dtype="M8[ns]", freq="2D")
@@ -321,7 +323,7 @@ def test_repr():
     ],
 )
 def test_upsample_sum(method, method_args, expected_values):
-    ser = Series(1, index=date_range("2017", periods=2, freq="h"))
+    ser = Series(1, index=date_range("2017", periods=2, freq="h", unit="ns"))
     resampled = ser.resample("30min")
     index = pd.DatetimeIndex(
         ["2017-01-01T00:00:00", "2017-01-01T00:30:00", "2017-01-01T01:00:00"],
@@ -337,7 +339,7 @@ def test_upsample_sum(method, method_args, expected_values):
 def groupy_test_df():
     return DataFrame(
         {"price": [10, 11, 9], "volume": [50, 60, 50]},
-        index=date_range("01/01/2018", periods=3, freq="W"),
+        index=date_range("01/01/2018", periods=3, freq="W", unit="ns"),
     )
 
 
@@ -373,7 +375,7 @@ def test_groupby_resample_interpolate_with_apply_syntax(groupy_test_df):
         )
 
         volume = [50] * 15 + [60]
-        week_starting = list(date_range("2018-01-07", "2018-01-21")) + [
+        week_starting = list(date_range("2018-01-07", "2018-01-21", unit="ns")) + [
             Timestamp("2018-01-14")
         ]
         expected_ind = pd.MultiIndex.from_arrays(
diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py
index 770e5cc3d2214..1b26b18c56b5a 100644
--- a/pandas/tests/reshape/concat/test_append_common.py
+++ b/pandas/tests/reshape/concat/test_append_common.py
@@ -298,7 +298,9 @@ def test_concatlike_datetimetz(self, tz_aware_fixture):
     @pytest.mark.parametrize("tz", ["UTC", "US/Eastern", "Asia/Tokyo", "EST5EDT"])
     def test_concatlike_datetimetz_short(self, tz):
         # GH#7795
-        ix1 = pd.date_range(start="2014-07-15", end="2014-07-17", freq="D", tz=tz)
+        ix1 = pd.date_range(
+            start="2014-07-15", end="2014-07-17", freq="D", tz=tz, unit="ns"
+        )
         ix2 = pd.DatetimeIndex(["2014-07-11", "2014-07-21"], tz=tz)
         df1 = DataFrame(0, index=ix1, columns=["A", "B"])
         df2 = DataFrame(0, index=ix2, columns=["A", "B"])
diff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py
index 198c652b43365..9b9eb404ceec5 100644
--- a/pandas/tests/reshape/concat/test_datetimes.py
+++ b/pandas/tests/reshape/concat/test_datetimes.py
@@ -48,8 +48,10 @@ def test_concat_datetime_datetime64_frame(self):
 
     def test_concat_datetime_timezone(self):
         # GH 18523
-        idx1 = date_range("2011-01-01", periods=3, freq="h", tz="Europe/Paris")
-        idx2 = date_range(start=idx1[0], end=idx1[-1], freq="h")
+        idx1 = date_range(
+            "2011-01-01", periods=3, freq="h", tz="Europe/Paris", unit="ns"
+        )
+        idx2 = date_range(start=idx1[0], end=idx1[-1], freq="h", unit="ns")
         df1 = DataFrame({"a": [1, 2, 3]}, index=idx1)
         df2 = DataFrame({"b": [1, 2, 3]}, index=idx2)
         result = concat([df1, df2], axis=1)
@@ -69,7 +71,7 @@ def test_concat_datetime_timezone(self):
 
         tm.assert_frame_equal(result, expected)
 
-        idx3 = date_range("2011-01-01", periods=3, freq="h", tz="Asia/Tokyo")
+        idx3 = date_range("2011-01-01", periods=3, freq="h", tz="Asia/Tokyo", unit="ns")
         df3 = DataFrame({"b": [1, 2, 3]}, index=idx3)
         msg = "Sorting by default when concatenating all DatetimeIndex"
         with tm.assert_produces_warning(Pandas4Warning, match=msg):
@@ -165,7 +167,13 @@ def test_concat_NaT_series(self):
         # GH 11693
         # test for merging NaT series with datetime series.
         x = Series(
-            date_range("20151124 08:00", "20151124 09:00", freq="1h", tz="US/Eastern")
+            date_range(
+                "20151124 08:00",
+                "20151124 09:00",
+                freq="1h",
+                tz="US/Eastern",
+                unit="ns",
+            )
         )
         y = Series(pd.NaT, index=[0, 1], dtype="datetime64[ns, US/Eastern]")
         expected = Series([x[0], x[1], pd.NaT, pd.NaT])
@@ -180,8 +188,8 @@ def test_concat_NaT_series(self):
 
     def test_concat_NaT_series2(self):
         # without tz
-        x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h"))
-        y = Series(date_range("20151124 10:00", "20151124 11:00", freq="1h"))
+        x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h", unit="ns"))
+        y = Series(date_range("20151124 10:00", "20151124 11:00", freq="1h", unit="ns"))
         y[:] = pd.NaT
         expected = Series([x[0], x[1], pd.NaT, pd.NaT])
         result = concat([x, y], ignore_index=True)
diff --git a/pandas/tests/reshape/concat/test_series.py b/pandas/tests/reshape/concat/test_series.py
index 05a0405473cc1..d49c62c9d7d80 100644
--- a/pandas/tests/reshape/concat/test_series.py
+++ b/pandas/tests/reshape/concat/test_series.py
@@ -29,7 +29,7 @@ def test_concat_bool_and_numeric(self, bool_dtype, dtype):
     def test_concat_series(self):
         ts = Series(
             np.arange(20, dtype=np.float64),
-            index=date_range("2020-01-01", periods=20),
+            index=date_range("2020-01-01", periods=20, unit="ns"),
             name="foo",
         )
         ts.name = "foo"
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index d188cb396a7da..f6796694621c3 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -847,22 +847,30 @@ def test_merge_datetime64tz_values(self):
         left = DataFrame(
             {
                 "key": [1, 2],
-                "value": pd.date_range("20151010", periods=2, tz="US/Eastern"),
+                "value": pd.date_range(
+                    "20151010", periods=2, tz="US/Eastern", unit="ns"
+                ),
             }
         )
         right = DataFrame(
             {
                 "key": [2, 3],
-                "value": pd.date_range("20151011", periods=2, tz="US/Eastern"),
+                "value": pd.date_range(
+                    "20151011", periods=2, tz="US/Eastern", unit="ns"
+                ),
             }
         )
         expected = DataFrame(
             {
                 "key": [1, 2, 3],
-                "value_x": list(pd.date_range("20151010", periods=2, tz="US/Eastern"))
+                "value_x": list(
+                    pd.date_range("20151010", periods=2, tz="US/Eastern", unit="ns")
+                )
                 + [pd.NaT],
                 "value_y": [pd.NaT]
-                + list(pd.date_range("20151011", periods=2, tz="US/Eastern")),
+                + list(
+                    pd.date_range("20151011", periods=2, tz="US/Eastern", unit="ns")
+                ),
             }
         )
         result = merge(left, right, on="key", how="outer")
diff --git a/pandas/tests/reshape/test_cut.py b/pandas/tests/reshape/test_cut.py
index cff097a1169cf..909c10d3f73b2 100644
--- a/pandas/tests/reshape/test_cut.py
+++ b/pandas/tests/reshape/test_cut.py
@@ -543,7 +543,7 @@ def test_datetime_tz_cut_mismatched_tzawareness(box):
 def test_datetime_tz_cut(bins, box):
     # see gh-19872
     tz = "US/Eastern"
-    ser = Series(date_range("20130101", periods=3, tz=tz))
+    ser = Series(date_range("20130101", periods=3, tz=tz, unit="ns"))
 
     if not isinstance(bins, int):
         bins = box(bins)
@@ -794,7 +794,7 @@ def test_cut_bins_datetime_intervalindex():
     # https://github.com/pandas-dev/pandas/issues/46218
     bins = interval_range(Timestamp("2022-02-25"), Timestamp("2022-02-27"), freq="1D")
     # passing Series instead of list is important to trigger bug
-    result = cut(Series([Timestamp("2022-02-26")]).astype("M8[ns]"), bins=bins)
+    result = cut(Series([Timestamp("2022-02-26")]), bins=bins)
     expected = Categorical.from_codes([0], bins, ordered=True)
     tm.assert_categorical_equal(result.array, expected)
 
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 22a73ae1b5ddb..5f47fb8f992d0 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -436,7 +436,7 @@ def test_pivot_no_values(self):
         df = DataFrame(
             {
                 "A": [1, 2, 3, 4, 5],
-                "dt": date_range("2011-01-01", freq="D", periods=5),
+                "dt": date_range("2011-01-01", freq="D", periods=5, unit="ns"),
             },
             index=idx,
         )
diff --git a/pandas/tests/reshape/test_qcut.py b/pandas/tests/reshape/test_qcut.py
index b6d45aeab8a7b..51617bc353680 100644
--- a/pandas/tests/reshape/test_qcut.py
+++ b/pandas/tests/reshape/test_qcut.py
@@ -221,7 +221,7 @@ def test_qcut_nat(ser, unit):
 def test_datetime_tz_qcut(bins):
     # see gh-19872
     tz = "US/Eastern"
-    ser = Series(date_range("20130101", periods=3, tz=tz))
+    ser = Series(date_range("20130101", periods=3, tz=tz, unit="ns"))
 
     result = qcut(ser, bins)
     expected = Series(
diff --git a/pandas/tests/series/accessors/test_cat_accessor.py b/pandas/tests/series/accessors/test_cat_accessor.py
index 7fb33f7d09d97..b8bbf770132c4 100644
--- a/pandas/tests/series/accessors/test_cat_accessor.py
+++ b/pandas/tests/series/accessors/test_cat_accessor.py
@@ -142,8 +142,8 @@ def test_categorical_delegations(self):
     @pytest.mark.parametrize(
         "idx",
         [
-            date_range("1/1/2015", periods=5),
-            date_range("1/1/2015", periods=5, tz="MET"),
+            date_range("1/1/2015", periods=5, unit="ns"),
+            date_range("1/1/2015", periods=5, tz="MET", unit="ns"),
             period_range("1/1/2015", freq="D", periods=5),
             timedelta_range("1 days", "10 days"),
         ],
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index 97cafc33611ed..9d0ae973d6c66 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -101,7 +101,7 @@ def test_getitem_setitem_datetime_tz(tz_source):
 def test_getitem_setitem_datetimeindex():
     N = 50
     # testing with timezone, GH #2785
-    rng = date_range("1/1/1990", periods=N, freq="h", tz="US/Eastern")
+    rng = date_range("1/1/1990", periods=N, freq="h", tz="US/Eastern", unit="ns")
     ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
 
     result = ts["1990-01-01 04:00:00"]
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 5c977de71ad84..35297482703c7 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -42,7 +42,7 @@
 
 class TestSetitemDT64Values:
     def test_setitem_none_nan(self):
-        series = Series(date_range("1/1/2000", periods=10))
+        series = Series(date_range("1/1/2000", periods=10, unit="ns"))
         series[3] = None
         assert series[3] is NaT
 
@@ -73,7 +73,7 @@ def test_setitem_with_string_index(self):
 
     def test_setitem_tuple_with_datetimetz_values(self):
         # GH#20441
-        arr = date_range("2017", periods=4, tz="US/Eastern")
+        arr = date_range("2017", periods=4, tz="US/Eastern", unit="ns")
         index = [(0, 1), (0, 2), (0, 3), (0, 4)]
         result = Series(arr, index=index)
         expected = result.copy()
@@ -83,7 +83,7 @@ def test_setitem_tuple_with_datetimetz_values(self):
 
     @pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Tokyo"])
     def test_setitem_with_tz(self, tz, indexer_sli):
-        orig = Series(date_range("2016-01-01", freq="h", periods=3, tz=tz))
+        orig = Series(date_range("2016-01-01", freq="h", periods=3, tz=tz, unit="ns"))
         assert orig.dtype == f"datetime64[ns, {tz}]"
 
         exp = Series(
@@ -124,7 +124,7 @@ def test_setitem_with_tz(self, tz, indexer_sli):
     def test_setitem_with_tz_dst(self, indexer_sli):
         # GH#14146 trouble setting values near DST boundary
         tz = "US/Eastern"
-        orig = Series(date_range("2016-11-06", freq="h", periods=3, tz=tz))
+        orig = Series(date_range("2016-11-06", freq="h", periods=3, tz=tz, unit="ns"))
         assert orig.dtype == f"datetime64[ns, {tz}]"
 
         exp = Series(
@@ -1516,7 +1516,7 @@ class TestCoercionDatetime64(CoercionTest):
 
     @pytest.fixture
     def obj(self):
-        return Series(date_range("2011-01-01", freq="D", periods=4))
+        return Series(date_range("2011-01-01", freq="D", periods=4, unit="ns"))
 
     @pytest.fixture
     def raises(self):
@@ -1538,7 +1538,7 @@ class TestCoercionDatetime64TZ(CoercionTest):
     @pytest.fixture
     def obj(self):
         tz = "US/Eastern"
-        return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz))
+        return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz, unit="ns"))
 
     @pytest.fixture
     def raises(self):
diff --git a/pandas/tests/series/methods/test_astype.py b/pandas/tests/series/methods/test_astype.py
index 81648377942f7..11e37bfa8befc 100644
--- a/pandas/tests/series/methods/test_astype.py
+++ b/pandas/tests/series/methods/test_astype.py
@@ -257,7 +257,7 @@ def test_astype_datetime(self, unit):
         assert ser.dtype == np.object_
 
     def test_astype_datetime64tz(self):
-        ser = Series(date_range("20130101", periods=3, tz="US/Eastern"))
+        ser = Series(date_range("20130101", periods=3, tz="US/Eastern", unit="ns"))
 
         # astype
         result = ser.astype(object)
@@ -283,7 +283,9 @@ def test_astype_datetime64tz(self):
             Series(ser.values).astype(ser.dtype)
 
         result = ser.astype("datetime64[ns, CET]")
-        expected = Series(date_range("20130101 06:00:00", periods=3, tz="CET"))
+        expected = Series(
+            date_range("20130101 06:00:00", periods=3, tz="CET", unit="ns")
+        )
         tm.assert_series_equal(result, expected)
 
     def test_astype_str_cast_dt64(self):
diff --git a/pandas/tests/series/methods/test_diff.py b/pandas/tests/series/methods/test_diff.py
index 89c34aeb64206..ee94e46ae4191 100644
--- a/pandas/tests/series/methods/test_diff.py
+++ b/pandas/tests/series/methods/test_diff.py
@@ -68,7 +68,8 @@ def test_diff_dt64(self):
     def test_diff_dt64tz(self):
         # with tz
         ser = Series(
-            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
+            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern", unit="ns"),
+            name="foo",
         )
         result = ser.diff()
         expected = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
diff --git a/pandas/tests/series/methods/test_get_numeric_data.py b/pandas/tests/series/methods/test_get_numeric_data.py
index 4a11d7905f506..31225d595343d 100644
--- a/pandas/tests/series/methods/test_get_numeric_data.py
+++ b/pandas/tests/series/methods/test_get_numeric_data.py
@@ -25,7 +25,7 @@ def test_get_numeric_data_preserve_dtype(self):
         result = obj._get_numeric_data()
         tm.assert_series_equal(result, obj)
 
-        obj = Series(date_range("20130101", periods=3))
+        obj = Series(date_range("20130101", periods=3, unit="ns"))
         result = obj._get_numeric_data()
         expected = Series([], dtype="M8[ns]")
         tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_reindex.py b/pandas/tests/series/methods/test_reindex.py
index cd48db82d7fe7..a99ed68ec9edb 100644
--- a/pandas/tests/series/methods/test_reindex.py
+++ b/pandas/tests/series/methods/test_reindex.py
@@ -321,8 +321,8 @@ def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value):
 
 def test_reindex_datetimeindexes_tz_naive_and_aware():
     # GH 8306
-    idx = date_range("20131101", tz="America/Chicago", periods=7)
-    newidx = date_range("20131103", periods=10, freq="h")
+    idx = date_range("20131101", tz="America/Chicago", periods=7, unit="ns")
+    newidx = date_range("20131103", periods=10, freq="h", unit="ns")
     s = Series(range(7), index=idx)
     msg = (
         r"Cannot compare dtypes datetime64\[ns, America/Chicago\] "
diff --git a/pandas/tests/series/methods/test_reset_index.py b/pandas/tests/series/methods/test_reset_index.py
index 3ff39b41a352d..03a18262f5b77 100644
--- a/pandas/tests/series/methods/test_reset_index.py
+++ b/pandas/tests/series/methods/test_reset_index.py
@@ -18,7 +18,9 @@
 
 class TestResetIndex:
     def test_reset_index_dti_round_trip(self):
-        dti = date_range(start="1/1/2001", end="6/1/2001", freq="D")._with_freq(None)
+        dti = date_range(
+            start="1/1/2001", end="6/1/2001", freq="D", unit="ns"
+        )._with_freq(None)
         d1 = DataFrame({"v": np.random.default_rng(2).random(len(dti))}, index=dti)
         d2 = d1.reset_index()
         assert d2.dtypes.iloc[0] == np.dtype("M8[ns]")
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 488eb99f81ef5..628969fa1cbb3 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -303,7 +303,7 @@ def test_mul_empty_int_corner_case(self):
     def test_sub_datetimelike_align(self):
         # GH#7500
         # datetimelike ops need to align
-        dt = Series(date_range("2012-1-1", periods=3, freq="D"))
+        dt = Series(date_range("2012-1-1", periods=3, freq="D", unit="ns"))
         dt.iloc[2] = np.nan
         dt2 = dt[::-1]
 
@@ -355,8 +355,8 @@ def test_arithmetic_with_duplicate_index(self):
 
         # GH#8363
         # datetime ops with a non-unique index
-        ser = Series(date_range("20130101 09:00:00", periods=5), index=index)
-        other = Series(date_range("20130101", periods=5), index=index)
+        ser = Series(date_range("20130101 09:00:00", periods=5, unit="ns"), index=index)
+        other = Series(date_range("20130101", periods=5, unit="ns"), index=index)
         result = ser - other
         expected = Series(Timedelta("9 hours"), index=[2, 2, 3, 3, 4])
         tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 2f1e4ee9a620e..14d5295e3f082 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -1112,7 +1112,7 @@ def test_constructor_with_datetime_tz(self):
         # 8260
         # support datetime64 with tz
 
-        dr = date_range("20130101", periods=3, tz="US/Eastern")
+        dr = date_range("20130101", periods=3, tz="US/Eastern", unit="ns")
         s = Series(dr)
         assert s.dtype.name == "datetime64[ns, US/Eastern]"
         assert s.dtype == "datetime64[ns, US/Eastern]"
@@ -1157,7 +1157,7 @@ def test_constructor_with_datetime_tz(self):
 
     def test_constructor_with_datetime_tz5(self):
         # long str
-        ser = Series(date_range("20130101", periods=1000, tz="US/Eastern"))
+        ser = Series(date_range("20130101", periods=1000, tz="US/Eastern", unit="ns"))
         assert "datetime64[ns, US/Eastern]" in str(ser)
 
     def test_constructor_with_datetime_tz4(self):
@@ -1615,7 +1615,7 @@ def test_constructor_name_unhashable(self):
                     Series(data, name=n)
 
     def test_auto_conversion(self):
-        series = Series(list(date_range("1/1/2000", periods=10)))
+        series = Series(list(date_range("1/1/2000", periods=10, unit="ns")))
         assert series.dtype == "M8[ns]"
 
     def test_convert_non_ns(self):
diff --git a/pandas/tests/series/test_formats.py b/pandas/tests/series/test_formats.py
index f38a12170c918..721270d98b380 100644
--- a/pandas/tests/series/test_formats.py
+++ b/pandas/tests/series/test_formats.py
@@ -416,7 +416,7 @@ def test_categorical_series_repr_ordered(self):
         assert repr(s) == exp
 
     def test_categorical_series_repr_datetime(self):
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, unit="ns")
         s = Series(Categorical(idx))
         exp = """0   2011-01-01 09:00:00
 1   2011-01-01 10:00:00
@@ -429,7 +429,9 @@ def test_categorical_series_repr_datetime(self):
 
         assert repr(s) == exp
 
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        idx = date_range(
+            "2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern", unit="ns"
+        )
         s = Series(Categorical(idx))
         exp = """0   2011-01-01 09:00:00-05:00
 1   2011-01-01 10:00:00-05:00
@@ -444,7 +446,7 @@ def test_categorical_series_repr_datetime(self):
         assert repr(s) == exp
 
     def test_categorical_series_repr_datetime_ordered(self):
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5)
+        idx = date_range("2011-01-01 09:00", freq="h", periods=5, unit="ns")
         s = Series(Categorical(idx, ordered=True))
         exp = """0   2011-01-01 09:00:00
 1   2011-01-01 10:00:00
@@ -457,7 +459,9 @@ def test_categorical_series_repr_datetime_ordered(self):
 
         assert repr(s) == exp
 
-        idx = date_range("2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern")
+        idx = date_range(
+            "2011-01-01 09:00", freq="h", periods=5, tz="US/Eastern", unit="ns"
+        )
         s = Series(Categorical(idx, ordered=True))
         exp = """0   2011-01-01 09:00:00-05:00
 1   2011-01-01 10:00:00-05:00
diff --git a/pandas/tests/series/test_reductions.py b/pandas/tests/series/test_reductions.py
index 5ffada8b95753..d0be93324dde5 100644
--- a/pandas/tests/series/test_reductions.py
+++ b/pandas/tests/series/test_reductions.py
@@ -104,7 +104,7 @@ def test_td64_sum_empty(skipna):
 
 def test_td64_summation_overflow():
     # GH#9442
-    ser = Series(pd.date_range("20130101", periods=100000, freq="h"))
+    ser = Series(pd.date_range("20130101", periods=100000, freq="h", unit="ns"))
     ser[0] += pd.Timedelta("1s 1ms")
 
     # mean
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 67b1e8668e5f6..18926d19153d6 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -2542,7 +2542,7 @@ def test_to_datetime_other_datetime64_units(self):
         assert value == as_obj
 
     def test_to_datetime_list_of_integers(self):
-        rng = date_range("1/1/2000", periods=20)
+        rng = date_range("1/1/2000", periods=20, unit="ns")
         rng = DatetimeIndex(rng.values)
 
         ints = list(rng.asi8)
@@ -2556,7 +2556,7 @@ def test_to_datetime_overflow(self):
         # we are overflowing Timedelta range here
         msg = "Cannot cast 139999 days 00:00:00 to unit='ns' without overflow"
         with pytest.raises(OutOfBoundsTimedelta, match=msg):
-            date_range(start="1/1/1700", freq="B", periods=100000)
+            date_range(start="1/1/1700", freq="B", periods=100000, unit="ns")
 
     def test_to_datetime_float_with_nans_floating_point_error(self):
         # GH#58419
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 05e1d50a86d3c..7563fbdd56a12 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -152,10 +152,7 @@ def test_fifth_week_of_month():
     # see gh-9425
     #
     # Only supports freq up to WOM-4.
-    msg = (
-        "Of the four parameters: start, end, periods, "
-        "and freq, exactly three must be specified"
-    )
+    msg = "Invalid frequency: WOM-5MON"
 
     with pytest.raises(ValueError, match=msg):
         date_range("2014-01-01", freq="WOM-5MON")
diff --git a/pandas/tests/tseries/holiday/test_federal.py b/pandas/tests/tseries/holiday/test_federal.py
index 2565877f8a2a4..789ac6c7d585c 100644
--- a/pandas/tests/tseries/holiday/test_federal.py
+++ b/pandas/tests/tseries/holiday/test_federal.py
@@ -50,7 +50,7 @@ def test_federal_holiday_inconsistent_returntype():
 
     results_2018 = cal1.holidays(start=datetime(2018, 8, 1), end=datetime(2018, 8, 31))
     results_2019 = cal2.holidays(start=datetime(2019, 8, 1), end=datetime(2019, 8, 31))
-    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+    expected_results = DatetimeIndex([], dtype="datetime64[us]", freq=None)
 
     # Check against expected results to ensure both date
     # ranges generate expected results as per GH49075 submission
diff --git a/pandas/tests/tseries/holiday/test_holiday.py b/pandas/tests/tseries/holiday/test_holiday.py
index 966d6bad46fbf..9d8cb60fcfd16 100644
--- a/pandas/tests/tseries/holiday/test_holiday.py
+++ b/pandas/tests/tseries/holiday/test_holiday.py
@@ -328,7 +328,7 @@ class TestHolidayCalendar(AbstractHolidayCalendar):
     start = Timestamp("2022-08-01")
     end = Timestamp("2022-08-31")
     year_offset = DateOffset(years=5)
-    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+    expected_results = DatetimeIndex([], dtype="datetime64[us]", freq=None)
     test_cal = TestHolidayCalendar()
 
     date_interval_low = test_cal.holidays(start - year_offset, end - year_offset)
@@ -350,7 +350,6 @@ def test_holidays_with_timezone_specified_but_no_occurrences():
         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)
 
@@ -378,7 +377,7 @@ def test_holiday_with_exclusion():
             Timestamp("2024-05-27"),
             Timestamp("2025-05-26"),
         ],
-        dtype="datetime64[ns]",
+        dtype="datetime64[us]",
     )
     tm.assert_index_equal(result, expected)
 
@@ -440,7 +439,7 @@ def test_holiday_with_multiple_exclusions():
             Timestamp("2064-01-01"),
             Timestamp("2065-01-01"),
         ],
-        dtype="datetime64[ns]",
+        dtype="datetime64[us]",
     )
     tm.assert_index_equal(result, expected)
 
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
index 1cccfe43519cd..5a6d76d78df53 100644
--- a/pandas/tests/tslibs/test_conversion.py
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -68,8 +68,8 @@ def test_tz_localize_to_utc_copies():
 
 def test_tz_convert_single_matches_tz_convert_hourly(tz_aware_fixture):
     tz = tz_aware_fixture
-    tz_didx = date_range("2014-03-01", "2014-04-01", freq="h", tz=tz)
-    naive_didx = date_range("2014-03-01", "2014-04-01", freq="h")
+    tz_didx = date_range("2014-03-01", "2014-04-01", freq="h", tz=tz, unit="ns")
+    naive_didx = date_range("2014-03-01", "2014-04-01", freq="h", unit="ns")
 
     _compare_utc_to_local(tz_didx)
     _compare_local_to_utc(tz_didx, naive_didx)
@@ -78,8 +78,8 @@ def test_tz_convert_single_matches_tz_convert_hourly(tz_aware_fixture):
 @pytest.mark.parametrize("freq", ["D", "YE"])
 def test_tz_convert_single_matches_tz_convert(tz_aware_fixture, freq):
     tz = tz_aware_fixture
-    tz_didx = date_range("2018-01-01", "2020-01-01", freq=freq, tz=tz)
-    naive_didx = date_range("2018-01-01", "2020-01-01", freq=freq)
+    tz_didx = date_range("2018-01-01", "2020-01-01", freq=freq, tz=tz, unit="ns")
+    naive_didx = date_range("2018-01-01", "2020-01-01", freq=freq, unit="ns")
 
     _compare_utc_to_local(tz_didx)
     _compare_local_to_utc(tz_didx, naive_didx)
diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index 8c9fff8e6ae2d..683ca1d875ac5 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -239,8 +239,8 @@ def test_series_equal_datetime_values_mismatch(rtol):
 \\[left\\]:  \\[1514764800000000000, 1514851200000000000, 1514937600000000000\\]
 \\[right\\]: \\[1549065600000000000, 1549152000000000000, 1549238400000000000\\]"""
 
-    s1 = Series(pd.date_range("2018-01-01", periods=3, freq="D"))
-    s2 = Series(pd.date_range("2019-02-02", periods=3, freq="D"))
+    s1 = Series(pd.date_range("2018-01-01", periods=3, freq="D", unit="ns"))
+    s2 = Series(pd.date_range("2019-02-02", periods=3, freq="D", unit="ns"))
 
     with pytest.raises(AssertionError, match=msg):
         tm.assert_series_equal(s1, s2, rtol=rtol)
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index dff307b595a3a..5a54a96f555f0 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -2003,7 +2003,8 @@ def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
 def test_rolling_timedelta_window_non_nanoseconds(unit, tz):
     # Test Sum, GH#55106
     df_time = DataFrame(
-        {"A": range(5)}, index=date_range("2013-01-01", freq="1s", periods=5, tz=tz)
+        {"A": range(5)},
+        index=date_range("2013-01-01", freq="1s", periods=5, tz=tz, unit="ns"),
     )
     sum_in_nanosecs = df_time.rolling("1s").sum()
     # microseconds / milliseconds should not break the correct rolling