code: """ test the scalar Timestamp """
  
  import calendar
  from datetime import (
      datetime,
      timedelta,
  )
  import locale
  import pickle
  import unicodedata
  
  from dateutil.tz import tzutc
  import numpy as np
  import pytest
  import pytz
  from pytz import (
      timezone,
      utc,
  )
  
  from pandas._libs.tslibs.timezones import (
      dateutil_gettz as gettz,
      get_timezone,
  )
  import pandas.util._test_decorators as td
  
  from pandas import (
      NaT,
      Timedelta,
      Timestamp,
  )
  import pandas._testing as tm
  
  from pandas.tseries import offsets
  
  
  class TestTimestampProperties:
      def test_freq_deprecation(self):
          # GH#41586
          msg = "The 'freq' argument in Timestamp is deprecated"
          with tm.assert_produces_warning(FutureWarning, match=msg):
              # warning issued at construction
              ts = Timestamp("2021-06-01", freq="D")
              ts2 = Timestamp("2021-06-01", freq="B")
  
          msg = "Timestamp.freq is deprecated"
          with tm.assert_produces_warning(FutureWarning, match=msg):
              # warning issued at attribute lookup
              ts.freq
  
          for per in ["month", "quarter", "year"]:
              for side in ["start", "end"]:
                  attr = f"is_{per}_{side}"
  
                  with tm.assert_produces_warning(FutureWarning, match=msg):
                      getattr(ts2, attr)
  
                  # is_(month|quarter|year)_(start|end) does _not_ issue a warning
                  #  with freq="D" bc the result will be unaffected by the deprecation
                  with tm.assert_produces_warning(None):
                      getattr(ts, attr)
  
      @pytest.mark.filterwarnings("ignore:The 'freq' argument:FutureWarning")
      @pytest.mark.filterwarnings("ignore:Timestamp.freq is deprecated:FutureWarning")
      def test_properties_business(self):
          ts = Timestamp("2017-10-01", freq="B")
          control = Timestamp("2017-10-01")
          assert ts.dayofweek == 6
          assert ts.day_of_week == 6
          assert not ts.is_month_start  # not a weekday
          assert not ts.freq.is_month_start(ts)
          assert ts.freq.is_month_start(ts + Timedelta(days=1))
          assert not ts.is_quarter_start  # not a weekday
          assert not ts.freq.is_quarter_start(ts)
          assert ts.freq.is_quarter_start(ts + Timedelta(days=1))
          # Control case: non-business is month/qtr start
          assert control.is_month_start
          assert control.is_quarter_start
  
          ts = Timestamp("2017-09-30", freq="B")
          control = Timestamp("2017-09-30")
          assert ts.dayofweek == 5
          assert ts.day_of_week == 5
          assert not ts.is_month_end  # not a weekday
          assert not ts.freq.is_month_end(ts)
          assert ts.freq.is_month_end(ts - Timedelta(days=1))
          assert not ts.is_quarter_end  # not a weekday
          assert not ts.freq.is_quarter_end(ts)
          assert ts.freq.is_quarter_end(ts - Timedelta(days=1))
          # Control case: non-business is month/qtr start
          assert control.is_month_end
          assert control.is_quarter_end
  
      @pytest.mark.parametrize(
          "attr, expected",
          [
              ["year", 2014],
              ["month", 12],
              ["day", 31],
              ["hour", 23],
              ["minute", 59],
              ["second", 0],
              ["microsecond", 0],
              ["nanosecond", 0],
              ["dayofweek", 2],
              ["day_of_week", 2],
              ["quarter", 4],
              ["dayofyear", 365],
              ["day_of_year", 365],
              ["week", 1],
              ["daysinmonth", 31],
          ],
      )
      @pytest.mark.parametrize("tz", [None, "US/Eastern"])
      def test_fields(self, attr, expected, tz):
          # GH 10050
          # GH 13303
          ts = Timestamp("2014-12-31 23:59:00", tz=tz)
          result = getattr(ts, attr)
          # that we are int like
          assert isinstance(result, int)
          assert result == expected
  
      @pytest.mark.parametrize("tz", [None, "US/Eastern"])
      def test_millisecond_raises(self, tz):
          ts = Timestamp("2014-12-31 23:59:00", tz=tz)
          msg = "'Timestamp' object has no attribute 'millisecond'"
          with pytest.raises(AttributeError, match=msg):
              ts.millisecond
  
      @pytest.mark.parametrize(
          "start", ["is_month_start", "is_quarter_start", "is_year_start"]
      )
      @pytest.mark.parametrize("tz", [None, "US/Eastern"])
      def test_is_start(self, start, tz):
          ts = Timestamp("2014-01-01 00:00:00", tz=tz)
          assert getattr(ts, start)
  
      @pytest.mark.parametrize("end", ["is_month_end", "is_year_end", "is_quarter_end"])
      @pytest.mark.parametrize("tz", [None, "US/Eastern"])
      def test_is_end(self, end, tz):
          ts = Timestamp("2014-12-31 23:59:59", tz=tz)
          assert getattr(ts, end)
  
      # GH 12806
      @pytest.mark.parametrize(
          "data",
          [Timestamp("2017-08-28 23:00:00"), Timestamp("2017-08-28 23:00:00", tz="EST")],
      )
      # error: Unsupported operand types for + ("List[None]" and "List[str]")
      @pytest.mark.parametrize(
          "time_locale", [None] + (tm.get_locales() or [])  # type: ignore[operator]
      )
      def test_names(self, data, time_locale):
          # GH 17354
          # Test .day_name(), .month_name
          if time_locale is None:
              expected_day = "Monday"
              expected_month = "August"
          else:
              with tm.set_locale(time_locale, locale.LC_TIME):
                  expected_day = calendar.day_name[0].capitalize()
                  expected_month = calendar.month_name[8].capitalize()
  
          result_day = data.day_name(time_locale)
          result_month = data.month_name(time_locale)
  
          # Work around https://github.com/pandas-dev/pandas/issues/22342
          # different normalizations
          expected_day = unicodedata.normalize("NFD", expected_day)
          expected_month = unicodedata.normalize("NFD", expected_month)
  
          result_day = unicodedata.normalize("NFD", result_day)
          result_month = unicodedata.normalize("NFD", result_month)
  
          assert result_day == expected_day
          assert result_month == expected_month
  
          # Test NaT
          nan_ts = Timestamp(NaT)
          assert np.isnan(nan_ts.day_name(time_locale))
          assert np.isnan(nan_ts.month_name(time_locale))
  
      def test_is_leap_year(self, tz_naive_fixture):
          tz = tz_naive_fixture
          # GH 13727
          dt = Timestamp("2000-01-01 00:00:00", tz=tz)
          assert dt.is_leap_year
          assert isinstance(dt.is_leap_year, bool)
  
          dt = Timestamp("1999-01-01 00:00:00", tz=tz)
          assert not dt.is_leap_year
  
          dt = Timestamp("2004-01-01 00:00:00", tz=tz)
          assert dt.is_leap_year
  
          dt = Timestamp("2100-01-01 00:00:00", tz=tz)
          assert not dt.is_leap_year
  
      def test_woy_boundary(self):
          # make sure weeks at year boundaries are correct
          d = datetime(2013, 12, 31)
          result = Timestamp(d).week
          expected = 1  # ISO standard
          assert result == expected
  
          d = datetime(2008, 12, 28)
          result = Timestamp(d).week
          expected = 52  # ISO standard
          assert result == expected
  
          d = datetime(2009, 12, 31)
          result = Timestamp(d).week
          expected = 53  # ISO standard
          assert result == expected
  
          d = datetime(2010, 1, 1)
          result = Timestamp(d).week
          expected = 53  # ISO standard
          assert result == expected
  
          d = datetime(2010, 1, 3)
          result = Timestamp(d).week
          expected = 53  # ISO standard
          assert result == expected
  
          result = np.array(
              [
                  Timestamp(datetime(*args)).week
                  for args in [(2000, 1, 1), (2000, 1, 2), (2005, 1, 1), (2005, 1, 2)]
              ]
          )
          assert (result == [52, 52, 53, 53]).all()
  
      def test_resolution(self):
          # GH#21336, GH#21365
          dt = Timestamp("2100-01-01 00:00:00")
          assert dt.resolution == Timedelta(nanoseconds=1)
  
          # Check that the attribute is available on the class, mirroring
          #  the stdlib datetime behavior
          assert Timestamp.resolution == Timedelta(nanoseconds=1)
  
  
  class TestTimestamp:
      def test_tz(self):
          tstr = "2014-02-01 09:00"
          ts = Timestamp(tstr)
          local = ts.tz_localize("Asia/Tokyo")
          assert local.hour == 9
          assert local == Timestamp(tstr, tz="Asia/Tokyo")
          conv = local.tz_convert("US/Eastern")
          assert conv == Timestamp("2014-01-31 19:00", tz="US/Eastern")
          assert conv.hour == 19
  
          # preserves nanosecond
          ts = Timestamp(tstr) + offsets.Nano(5)
          local = ts.tz_localize("Asia/Tokyo")
          assert local.hour == 9
          assert local.nanosecond == 5
          conv = local.tz_convert("US/Eastern")
          assert conv.nanosecond == 5
          assert conv.hour == 19
  
      def test_utc_z_designator(self):
          assert get_timezone(Timestamp("2014-11-02 01:00Z").tzinfo) is utc
  
      def test_asm8(self):
          np.random.seed(7_960_929)
          ns = [Timestamp.min.value, Timestamp.max.value, 1000]
  
          for n in ns:
              assert (
                  Timestamp(n).asm8.view("i8") == np.datetime64(n, "ns").view("i8") == n
              )
  
          assert Timestamp("nat").asm8.view("i8") == np.datetime64("nat", "ns").view("i8")
  
      def test_class_ops_pytz(self):
          def compare(x, y):
              assert int((Timestamp(x).value - Timestamp(y).value) / 1e9) == 0
  
          compare(Timestamp.now(), datetime.now())
          compare(Timestamp.now("UTC"), datetime.now(timezone("UTC")))
          compare(Timestamp.utcnow(), datetime.utcnow())
          compare(Timestamp.today(), datetime.today())
          current_time = calendar.timegm(datetime.now().utctimetuple())
          msg = "timezone-aware Timestamp with UTC"
          with tm.assert_produces_warning(FutureWarning, match=msg):
              # GH#22451
              ts_utc = Timestamp.utcfromtimestamp(current_time)
          compare(
              ts_utc,
              datetime.utcfromtimestamp(current_time),
          )
          compare(
              Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time)
          )
          compare(
              # Support tz kwarg in Timestamp.fromtimestamp
              Timestamp.fromtimestamp(current_time, "UTC"),
              datetime.fromtimestamp(current_time, utc),
          )
          compare(
              # Support tz kwarg in Timestamp.fromtimestamp
              Timestamp.fromtimestamp(current_time, tz="UTC"),
              datetime.fromtimestamp(current_time, utc),
          )
  
          date_component = datetime.utcnow()
          time_component = (date_component + timedelta(minutes=10)).time()
          compare(
              Timestamp.combine(date_component, time_component),
              datetime.combine(date_component, time_component),
          )
  
      def test_class_ops_dateutil(self):
          def compare(x, y):
              assert (
                  int(
                      np.round(Timestamp(x).value / 1e9)
                      - np.round(Timestamp(y).value / 1e9)
                  )
                  == 0
              )
  
          compare(Timestamp.now(), datetime.now())
          compare(Timestamp.now("UTC"), datetime.now(tzutc()))
          compare(Timestamp.utcnow(), datetime.utcnow())
          compare(Timestamp.today(), datetime.today())
          current_time = calendar.timegm(datetime.now().utctimetuple())
  
          msg = "timezone-aware Timestamp with UTC"
          with tm.assert_produces_warning(FutureWarning, match=msg):
              # GH#22451
              ts_utc = Timestamp.utcfromtimestamp(current_time)
  
          compare(
              ts_utc,
              datetime.utcfromtimestamp(current_time),
          )
          compare(
              Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time)
          )
  
          date_component = datetime.utcnow()
          time_component = (date_component + timedelta(minutes=10)).time()
          compare(
              Timestamp.combine(date_component, time_component),
              datetime.combine(date_component, time_component),
          )
  
      def test_basics_nanos(self):
          val = np.int64(946_684_800_000_000_000).view("M8[ns]")
          stamp = Timestamp(val.view("i8") + 500)
          assert stamp.year == 2000
          assert stamp.month == 1
          assert stamp.microsecond == 0
          assert stamp.nanosecond == 500
  
          # GH 14415
          val = np.iinfo(np.int64).min + 80_000_000_000_000
          stamp = Timestamp(val)
          assert stamp.year == 1677
          assert stamp.month == 9
          assert stamp.day == 21
          assert stamp.microsecond == 145224
          assert stamp.nanosecond == 192
  
      @pytest.mark.parametrize(
          "value, check_kwargs",
          [
              [946688461000000000, {}],
              [946688461000000000 / 1000, {"unit": "us"}],
              [946688461000000000 / 1_000_000, {"unit": "ms"}],
              [946688461000000000 / 1_000_000_000, {"unit": "s"}],
              [10957, {"unit": "D", "h": 0}],
              [
                  (946688461000000000 + 500000) / 1000000000,
                  {"unit": "s", "us": 499, "ns": 964},
              ],
              [
                  (946688461000000000 + 500000000) / 1000000000,
                  {"unit": "s", "us": 500000},
              ],
              [(946688461000000000 + 500000) / 1000000, {"unit": "ms", "us": 500}],
              [(946688461000000000 + 500000) / 1000, {"unit": "us", "us": 500}],
              [(946688461000000000 + 500000000) / 1000000, {"unit": "ms", "us": 500000}],
              [946688461000000000 / 1000.0 + 5, {"unit": "us", "us": 5}],
              [946688461000000000 / 1000.0 + 5000, {"unit": "us", "us": 5000}],
              [946688461000000000 / 1000000.0 + 0.5, {"unit": "ms", "us": 500}],
              [946688461000000000 / 1000000.0 + 0.005, {"unit": "ms", "us": 5, "ns": 5}],
              [946688461000000000 / 1000000000.0 + 0.5, {"unit": "s", "us": 500000}],
              [10957 + 0.5, {"unit": "D", "h": 12}],
          ],
      )
      def test_unit(self, value, check_kwargs):
          def check(value, unit=None, h=1, s=1, us=0, ns=0):
              stamp = Timestamp(value, unit=unit)
              assert stamp.year == 2000
              assert stamp.month == 1
              assert stamp.day == 1
              assert stamp.hour == h
              if unit != "D":
                  assert stamp.minute == 1
                  assert stamp.second == s
                  assert stamp.microsecond == us
              else:
                  assert stamp.minute == 0
                  assert stamp.second == 0
                  assert stamp.microsecond == 0
              assert stamp.nanosecond == ns
  
          check(value, **check_kwargs)
  
      def test_roundtrip(self):
  
          # test value to string and back conversions
          # further test accessors
          base = Timestamp("20140101 00:00:00")
  
          result = Timestamp(base.value + Timedelta("5ms").value)
          assert result == Timestamp(f"{base}.005000")
          assert result.microsecond == 5000
  
          result = Timestamp(base.value + Timedelta("5us").value)
          assert result == Timestamp(f"{base}.000005")
          assert result.microsecond == 5
  
          result = Timestamp(base.value + Timedelta("5ns").value)
          assert result == Timestamp(f"{base}.000000005")
          assert result.nanosecond == 5
          assert result.microsecond == 0
  
          result = Timestamp(base.value + Timedelta("6ms 5us").value)
          assert result == Timestamp(f"{base}.006005")
          assert result.microsecond == 5 + 6 * 1000
  
          result = Timestamp(base.value + Timedelta("200ms 5us").value)
          assert result == Timestamp(f"{base}.200005")
          assert result.microsecond == 5 + 200 * 1000
  
      def test_hash_equivalent(self):
          d = {datetime(2011, 1, 1): 5}
          stamp = Timestamp(datetime(2011, 1, 1))
          assert d[stamp] == 5
  
      @pytest.mark.parametrize(
          "timezone, year, month, day, hour",
          [["America/Chicago", 2013, 11, 3, 1], ["America/Santiago", 2021, 4, 3, 23]],
      )
      def test_hash_timestamp_with_fold(self, timezone, year, month, day, hour):
          # see gh-33931
          test_timezone = gettz(timezone)
          transition_1 = Timestamp(
              year=year,
              month=month,
              day=day,
              hour=hour,
              minute=0,
              fold=0,
              tzinfo=test_timezone,
          )
          transition_2 = Timestamp(
              year=year,
              month=month,
              day=day,
              hour=hour,
              minute=0,
              fold=1,
              tzinfo=test_timezone,
          )
          assert hash(transition_1) == hash(transition_2)
  
      def test_tz_conversion_freq(self, tz_naive_fixture):
          # GH25241
          with tm.assert_produces_warning(FutureWarning, match="freq"):
              t1 = Timestamp("2019-01-01 10:00", freq="H")
              assert t1.tz_localize(tz=tz_naive_fixture).freq == t1.freq
          with tm.assert_produces_warning(FutureWarning, match="freq"):
              t2 = Timestamp("2019-01-02 12:00", tz="UTC", freq="T")
              assert t2.tz_convert(tz="UTC").freq == t2.freq
  
      def test_pickle_freq_no_warning(self):
          # GH#41949 we don't want a warning on unpickling
          with tm.assert_produces_warning(FutureWarning, match="freq"):
              ts = Timestamp("2019-01-01 10:00", freq="H")
  
          out = pickle.dumps(ts)
          with tm.assert_produces_warning(None):
              res = pickle.loads(out)
  
          assert res._freq == ts._freq
  
  
  class TestTimestampNsOperations:
      def test_nanosecond_string_parsing(self):
          ts = Timestamp("2013-05-01 07:15:45.123456789")
          # GH 7878
          expected_repr = "2013-05-01 07:15:45.123456789"
          expected_value = 1_367_392_545_123_456_789
          assert ts.value == expected_value
          assert expected_repr in repr(ts)
  
          ts = Timestamp("2013-05-01 07:15:45.123456789+09:00", tz="Asia/Tokyo")
          assert ts.value == expected_value - 9 * 3600 * 1_000_000_000
          assert expected_repr in repr(ts)
  
          ts = Timestamp("2013-05-01 07:15:45.123456789", tz="UTC")
          assert ts.value == expected_value
          assert expected_repr in repr(ts)
  
          ts = Timestamp("2013-05-01 07:15:45.123456789", tz="US/Eastern")
          assert ts.value == expected_value + 4 * 3600 * 1_000_000_000
          assert expected_repr in repr(ts)
  
          # GH 10041
          ts = Timestamp("20130501T071545.123456789")
          assert ts.value == expected_value
          assert expected_repr in repr(ts)
  
      def test_nanosecond_timestamp(self):
          # GH 7610
          expected = 1_293_840_000_000_000_005
          t = Timestamp("2011-01-01") + offsets.Nano(5)
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
          assert t.value == expected
          assert t.nanosecond == 5
  
          t = Timestamp(t)
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
          assert t.value == expected
          assert t.nanosecond == 5
  
          t = Timestamp("2011-01-01 00:00:00.000000005")
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
          assert t.value == expected
          assert t.nanosecond == 5
  
          expected = 1_293_840_000_000_000_010
          t = t + offsets.Nano(5)
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
          assert t.value == expected
          assert t.nanosecond == 10
  
          t = Timestamp(t)
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
          assert t.value == expected
          assert t.nanosecond == 10
  
          t = Timestamp("2011-01-01 00:00:00.000000010")
          assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
          assert t.value == expected
          assert t.nanosecond == 10
  
  
  class TestTimestampToJulianDate:
      def test_compare_1700(self):
          r = Timestamp("1700-06-23").to_julian_date()
          assert r == 2_342_145.5
  
      def test_compare_2000(self):
          r = Timestamp("2000-04-12").to_julian_date()
          assert r == 2_451_646.5
  
      def test_compare_2100(self):
          r = Timestamp("2100-08-12").to_julian_date()
          assert r == 2_488_292.5
  
      def test_compare_hour01(self):
          r = Timestamp("2000-08-12T01:00:00").to_julian_date()
          assert r == 2_451_768.5416666666666666
  
      def test_compare_hour13(self):
          r = Timestamp("2000-08-12T13:00:00").to_julian_date()
          assert r == 2_451_769.0416666666666666
  
  
  class TestTimestampConversion:
      def test_conversion(self):
          # GH#9255
          ts = Timestamp("2000-01-01")
  
          result = ts.to_pydatetime()
          expected = datetime(2000, 1, 1)
          assert result == expected
          assert type(result) == type(expected)
  
          result = ts.to_datetime64()
          expected = np.datetime64(ts.value, "ns")
          assert result == expected
          assert type(result) == type(expected)
          assert result.dtype == expected.dtype
  
      def test_to_pydatetime_nonzero_nano(self):
          ts = Timestamp("2011-01-01 9:00:00.123456789")
  
          # Warn the user of data loss (nanoseconds).
          with tm.assert_produces_warning(UserWarning):
              expected = datetime(2011, 1, 1, 9, 0, 0, 123456)
              result = ts.to_pydatetime()
              assert result == expected
  
      def test_timestamp_to_datetime(self):
          stamp = Timestamp("20090415", tz="US/Eastern")
          dtval = stamp.to_pydatetime()
          assert stamp == dtval
          assert stamp.tzinfo == dtval.tzinfo
  
      def test_timestamp_to_datetime_dateutil(self):
          stamp = Timestamp("20090415", tz="dateutil/US/Eastern")
          dtval = stamp.to_pydatetime()
          assert stamp == dtval
          assert stamp.tzinfo == dtval.tzinfo
  
      def test_timestamp_to_datetime_explicit_pytz(self):
          stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern"))
          dtval = stamp.to_pydatetime()
          assert stamp == dtval
          assert stamp.tzinfo == dtval.tzinfo
  
      @td.skip_if_windows
      def test_timestamp_to_datetime_explicit_dateutil(self):
          stamp = Timestamp("20090415", tz=gettz("US/Eastern"))
          dtval = stamp.to_pydatetime()
          assert stamp == dtval
          assert stamp.tzinfo == dtval.tzinfo
  
      def test_to_datetime_bijective(self):
          # Ensure that converting to datetime and back only loses precision
          # by going from nanoseconds to microseconds.
          exp_warning = None if Timestamp.max.nanosecond == 0 else UserWarning
          with tm.assert_produces_warning(exp_warning):
              pydt_max = Timestamp.max.to_pydatetime()
  
          assert Timestamp(pydt_max).value / 1000 == Timestamp.max.value / 1000
  
          exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning
          with tm.assert_produces_warning(exp_warning):
              pydt_min = Timestamp.min.to_pydatetime()
  
          # The next assertion can be enabled once GH#39221 is merged
          #  assert pydt_min < Timestamp.min  # this is bc nanos are dropped
          tdus = timedelta(microseconds=1)
          assert pydt_min + tdus > Timestamp.min
  
          assert Timestamp(pydt_min + tdus).value / 1000 == Timestamp.min.value / 1000
  
      def test_to_period_tz_warning(self):
          # GH#21333 make sure a warning is issued when timezone
          # info is lost
          ts = Timestamp("2009-04-15 16:17:18", tz="US/Eastern")
          with tm.assert_produces_warning(UserWarning):
              # warning that timezone info will be lost
              ts.to_period("D")
  
      def test_to_numpy_alias(self):
          # GH 24653: alias .to_numpy() for scalars
          ts = Timestamp(datetime.now())
          assert ts.to_datetime64() == ts.to_numpy()
  
          # GH#44460
          msg = "dtype and copy arguments are ignored"
          with pytest.raises(ValueError, match=msg):
              ts.to_numpy("M8[s]")
          with pytest.raises(ValueError, match=msg):
              ts.to_numpy(copy=True)
  
  
  class SubDatetime(datetime):
      pass
  
  
  @pytest.mark.parametrize(
      "lh,rh",
      [
          (SubDatetime(2000, 1, 1), Timedelta(hours=1)),
          (Timedelta(hours=1), SubDatetime(2000, 1, 1)),
      ],
  )
  def test_dt_subclass_add_timedelta(lh, rh):
      # GH#25851
      # ensure that subclassed datetime works for
      # Timedelta operations
      result = lh + rh
      expected = SubDatetime(2000, 1, 1, 1)
      assert result == expected
  
apis: pandas.tseries.offsets.Nano numpy.random.seed pandas.Timestamp.today numpy.int64 numpy.datetime64 pandas.Timestamp.fromtimestamp pandas._testing.assert_produces_warning pandas.Timestamp.now pandas._libs.tslibs.timezones.dateutil_gettz pandas.Timestamp pandas._testing.set_locale pandas.Timedelta pandas.Timestamp.utcfromtimestamp pandas.Timestamp.combine pandas.Timestamp.utcnow numpy.iinfo pandas.Timestamp.max.to_pydatetime pandas._testing.get_locales pandas.Timestamp.min.to_pydatetime