Add files using upload-large-folder tool

llava_next/lib/python3.10/site-packages/pandas/tests/indexes/test_common.py

@@ -0,0 +1,512 @@
+"""
+Collection of tests asserting things that should be true for
+any index subclass except for MultiIndex. Makes use of the `index_flat`
+fixture defined in pandas/conftest.py.
+"""
+from copy import (
+    copy,
+    deepcopy,
+)
+import re
+
+import numpy as np
+import pytest
+
+from pandas.compat import IS64
+from pandas.compat.numpy import np_version_gte1p25
+
+from pandas.core.dtypes.common import (
+    is_integer_dtype,
+    is_numeric_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    MultiIndex,
+    PeriodIndex,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+class TestCommon:
+    @pytest.mark.parametrize("name", [None, "new_name"])
+    def test_to_frame(self, name, index_flat, using_copy_on_write):
+        # see GH#15230, GH#22580
+        idx = index_flat
+
+        if name:
+            idx_name = name
+        else:
+            idx_name = idx.name or 0
+
+        df = idx.to_frame(name=idx_name)
+
+        assert df.index is idx
+        assert len(df.columns) == 1
+        assert df.columns[0] == idx_name
+        if not using_copy_on_write:
+            assert df[idx_name].values is not idx.values
+
+        df = idx.to_frame(index=False, name=idx_name)
+        assert df.index is not idx
+
+    def test_droplevel(self, index_flat):
+        # GH 21115
+        # MultiIndex is tested separately in test_multi.py
+        index = index_flat
+
+        assert index.droplevel([]).equals(index)
+
+        for level in [index.name, [index.name]]:
+            if isinstance(index.name, tuple) and level is index.name:
+                # GH 21121 : droplevel with tuple name
+                continue
+            msg = (
+                "Cannot remove 1 levels from an index with 1 levels: at least one "
+                "level must be left."
+            )
+            with pytest.raises(ValueError, match=msg):
+                index.droplevel(level)
+
+        for level in "wrong", ["wrong"]:
+            with pytest.raises(
+                KeyError,
+                match=r"'Requested level \(wrong\) does not match index name \(None\)'",
+            ):
+                index.droplevel(level)
+
+    def test_constructor_non_hashable_name(self, index_flat):
+        # GH 20527
+        index = index_flat
+
+        message = "Index.name must be a hashable type"
+        renamed = [["1"]]
+
+        # With .rename()
+        with pytest.raises(TypeError, match=message):
+            index.rename(name=renamed)
+
+        # With .set_names()
+        with pytest.raises(TypeError, match=message):
+            index.set_names(names=renamed)
+
+    def test_constructor_unwraps_index(self, index_flat):
+        a = index_flat
+        # Passing dtype is necessary for Index([True, False], dtype=object)
+        #  case.
+        b = type(a)(a, dtype=a.dtype)
+        tm.assert_equal(a._data, b._data)
+
+    def test_to_flat_index(self, index_flat):
+        # 22866
+        index = index_flat
+
+        result = index.to_flat_index()
+        tm.assert_index_equal(result, index)
+
+    def test_set_name_methods(self, index_flat):
+        # MultiIndex tested separately
+        index = index_flat
+        new_name = "This is the new name for this index"
+
+        original_name = index.name
+        new_ind = index.set_names([new_name])
+        assert new_ind.name == new_name
+        assert index.name == original_name
+        res = index.rename(new_name, inplace=True)
+
+        # should return None
+        assert res is None
+        assert index.name == new_name
+        assert index.names == [new_name]
+        with pytest.raises(ValueError, match="Level must be None"):
+            index.set_names("a", level=0)
+
+        # rename in place just leaves tuples and other containers alone
+        name = ("A", "B")
+        index.rename(name, inplace=True)
+        assert index.name == name
+        assert index.names == [name]
+
+    @pytest.mark.xfail
+    def test_set_names_single_label_no_level(self, index_flat):
+        with pytest.raises(TypeError, match="list-like"):
+            # should still fail even if it would be the right length
+            index_flat.set_names("a")
+
+    def test_copy_and_deepcopy(self, index_flat):
+        index = index_flat
+
+        for func in (copy, deepcopy):
+            idx_copy = func(index)
+            assert idx_copy is not index
+            assert idx_copy.equals(index)
+
+        new_copy = index.copy(deep=True, name="banana")
+        assert new_copy.name == "banana"
+
+    def test_copy_name(self, index_flat):
+        # GH#12309: Check that the "name" argument
+        # passed at initialization is honored.
+        index = index_flat
+
+        first = type(index)(index, copy=True, name="mario")
+        second = type(first)(first, copy=False)
+
+        # Even though "copy=False", we want a new object.
+        assert first is not second
+        tm.assert_index_equal(first, second)
+
+        # Not using tm.assert_index_equal() since names differ.
+        assert index.equals(first)
+
+        assert first.name == "mario"
+        assert second.name == "mario"
+
+        # TODO: belongs in series arithmetic tests?
+        s1 = pd.Series(2, index=first)
+        s2 = pd.Series(3, index=second[:-1])
+        # See GH#13365
+        s3 = s1 * s2
+        assert s3.index.name == "mario"
+
+    def test_copy_name2(self, index_flat):
+        # GH#35592
+        index = index_flat
+
+        assert index.copy(name="mario").name == "mario"
+
+        with pytest.raises(ValueError, match="Length of new names must be 1, got 2"):
+            index.copy(name=["mario", "luigi"])
+
+        msg = f"{type(index).__name__}.name must be a hashable type"
+        with pytest.raises(TypeError, match=msg):
+            index.copy(name=[["mario"]])
+
+    def test_unique_level(self, index_flat):
+        # don't test a MultiIndex here (as its tested separated)
+        index = index_flat
+
+        # GH 17896
+        expected = index.drop_duplicates()
+        for level in [0, index.name, None]:
+            result = index.unique(level=level)
+            tm.assert_index_equal(result, expected)
+
+        msg = "Too many levels: Index has only 1 level, not 4"
+        with pytest.raises(IndexError, match=msg):
+            index.unique(level=3)
+
+        msg = (
+            rf"Requested level \(wrong\) does not match index name "
+            rf"\({re.escape(index.name.__repr__())}\)"
+        )
+        with pytest.raises(KeyError, match=msg):
+            index.unique(level="wrong")
+
+    def test_unique(self, index_flat):
+        # MultiIndex tested separately
+        index = index_flat
+        if not len(index):
+            pytest.skip("Skip check for empty Index and MultiIndex")
+
+        idx = index[[0] * 5]
+        idx_unique = index[[0]]
+
+        # We test against `idx_unique`, so first we make sure it's unique
+        # and doesn't contain nans.
+        assert idx_unique.is_unique is True
+        try:
+            assert idx_unique.hasnans is False
+        except NotImplementedError:
+            pass
+
+        result = idx.unique()
+        tm.assert_index_equal(result, idx_unique)
+
+        # nans:
+        if not index._can_hold_na:
+            pytest.skip("Skip na-check if index cannot hold na")
+
+        vals = index._values[[0] * 5]
+        vals[0] = np.nan
+
+        vals_unique = vals[:2]
+        idx_nan = index._shallow_copy(vals)
+        idx_unique_nan = index._shallow_copy(vals_unique)
+        assert idx_unique_nan.is_unique is True
+
+        assert idx_nan.dtype == index.dtype
+        assert idx_unique_nan.dtype == index.dtype
+
+        expected = idx_unique_nan
+        for pos, i in enumerate([idx_nan, idx_unique_nan]):
+            result = i.unique()
+            tm.assert_index_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:Period with BDay freq:FutureWarning")
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_searchsorted_monotonic(self, index_flat, request):
+        # GH17271
+        index = index_flat
+        # not implemented for tuple searches in MultiIndex
+        # or Intervals searches in IntervalIndex
+        if isinstance(index, pd.IntervalIndex):
+            mark = pytest.mark.xfail(
+                reason="IntervalIndex.searchsorted does not support Interval arg",
+                raises=NotImplementedError,
+            )
+            request.applymarker(mark)
+
+        # nothing to test if the index is empty
+        if index.empty:
+            pytest.skip("Skip check for empty Index")
+        value = index[0]
+
+        # determine the expected results (handle dupes for 'right')
+        expected_left, expected_right = 0, (index == value).argmin()
+        if expected_right == 0:
+            # all values are the same, expected_right should be length
+            expected_right = len(index)
+
+        # test _searchsorted_monotonic in all cases
+        # test searchsorted only for increasing
+        if index.is_monotonic_increasing:
+            ssm_left = index._searchsorted_monotonic(value, side="left")
+            assert expected_left == ssm_left
+
+            ssm_right = index._searchsorted_monotonic(value, side="right")
+            assert expected_right == ssm_right
+
+            ss_left = index.searchsorted(value, side="left")
+            assert expected_left == ss_left
+
+            ss_right = index.searchsorted(value, side="right")
+            assert expected_right == ss_right
+
+        elif index.is_monotonic_decreasing:
+            ssm_left = index._searchsorted_monotonic(value, side="left")
+            assert expected_left == ssm_left
+
+            ssm_right = index._searchsorted_monotonic(value, side="right")
+            assert expected_right == ssm_right
+        else:
+            # non-monotonic should raise.
+            msg = "index must be monotonic increasing or decreasing"
+            with pytest.raises(ValueError, match=msg):
+                index._searchsorted_monotonic(value, side="left")
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_drop_duplicates(self, index_flat, keep):
+        # MultiIndex is tested separately
+        index = index_flat
+        if isinstance(index, RangeIndex):
+            pytest.skip(
+                "RangeIndex is tested in test_drop_duplicates_no_duplicates "
+                "as it cannot hold duplicates"
+            )
+        if len(index) == 0:
+            pytest.skip(
+                "empty index is tested in test_drop_duplicates_no_duplicates "
+                "as it cannot hold duplicates"
+            )
+
+        # make unique index
+        holder = type(index)
+        unique_values = list(set(index))
+        dtype = index.dtype if is_numeric_dtype(index) else None
+        unique_idx = holder(unique_values, dtype=dtype)
+
+        # make duplicated index
+        n = len(unique_idx)
+        duplicated_selection = np.random.default_rng(2).choice(n, int(n * 1.5))
+        idx = holder(unique_idx.values[duplicated_selection])
+
+        # Series.duplicated is tested separately
+        expected_duplicated = (
+            pd.Series(duplicated_selection).duplicated(keep=keep).values
+        )
+        tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected_duplicated)
+
+        # Series.drop_duplicates is tested separately
+        expected_dropped = holder(pd.Series(idx).drop_duplicates(keep=keep))
+        tm.assert_index_equal(idx.drop_duplicates(keep=keep), expected_dropped)
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_drop_duplicates_no_duplicates(self, index_flat):
+        # MultiIndex is tested separately
+        index = index_flat
+
+        # make unique index
+        if isinstance(index, RangeIndex):
+            # RangeIndex cannot have duplicates
+            unique_idx = index
+        else:
+            holder = type(index)
+            unique_values = list(set(index))
+            dtype = index.dtype if is_numeric_dtype(index) else None
+            unique_idx = holder(unique_values, dtype=dtype)
+
+        # check on unique index
+        expected_duplicated = np.array([False] * len(unique_idx), dtype="bool")
+        tm.assert_numpy_array_equal(unique_idx.duplicated(), expected_duplicated)
+        result_dropped = unique_idx.drop_duplicates()
+        tm.assert_index_equal(result_dropped, unique_idx)
+        # validate shallow copy
+        assert result_dropped is not unique_idx
+
+    def test_drop_duplicates_inplace(self, index):
+        msg = r"drop_duplicates\(\) got an unexpected keyword argument"
+        with pytest.raises(TypeError, match=msg):
+            index.drop_duplicates(inplace=True)
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_has_duplicates(self, index_flat):
+        # MultiIndex tested separately in:
+        #   tests/indexes/multi/test_unique_and_duplicates.
+        index = index_flat
+        holder = type(index)
+        if not len(index) or isinstance(index, RangeIndex):
+            # MultiIndex tested separately in:
+            #   tests/indexes/multi/test_unique_and_duplicates.
+            # RangeIndex is unique by definition.
+            pytest.skip("Skip check for empty Index, MultiIndex, and RangeIndex")
+
+        idx = holder([index[0]] * 5)
+        assert idx.is_unique is False
+        assert idx.has_duplicates is True
+
+    @pytest.mark.parametrize(
+        "dtype",
+        ["int64", "uint64", "float64", "category", "datetime64[ns]", "timedelta64[ns]"],
+    )
+    def test_astype_preserves_name(self, index, dtype):
+        # https://github.com/pandas-dev/pandas/issues/32013
+        if isinstance(index, MultiIndex):
+            index.names = ["idx" + str(i) for i in range(index.nlevels)]
+        else:
+            index.name = "idx"
+
+        warn = None
+        if index.dtype.kind == "c" and dtype in ["float64", "int64", "uint64"]:
+            # imaginary components discarded
+            if np_version_gte1p25:
+                warn = np.exceptions.ComplexWarning
+            else:
+                warn = np.ComplexWarning
+
+        is_pyarrow_str = str(index.dtype) == "string[pyarrow]" and dtype == "category"
+        try:
+            # Some of these conversions cannot succeed so we use a try / except
+            with tm.assert_produces_warning(
+                warn,
+                raise_on_extra_warnings=is_pyarrow_str,
+                check_stacklevel=False,
+            ):
+                result = index.astype(dtype)
+        except (ValueError, TypeError, NotImplementedError, SystemError):
+            return
+
+        if isinstance(index, MultiIndex):
+            assert result.names == index.names
+        else:
+            assert result.name == index.name
+
+    def test_hasnans_isnans(self, index_flat):
+        # GH#11343, added tests for hasnans / isnans
+        index = index_flat
+
+        # cases in indices doesn't include NaN
+        idx = index.copy(deep=True)
+        expected = np.array([False] * len(idx), dtype=bool)
+        tm.assert_numpy_array_equal(idx._isnan, expected)
+        assert idx.hasnans is False
+
+        idx = index.copy(deep=True)
+        values = idx._values
+
+        if len(index) == 0:
+            return
+        elif is_integer_dtype(index.dtype):
+            return
+        elif index.dtype == bool:
+            # values[1] = np.nan below casts to True!
+            return
+
+        values[1] = np.nan
+
+        idx = type(index)(values)
+
+        expected = np.array([False] * len(idx), dtype=bool)
+        expected[1] = True
+        tm.assert_numpy_array_equal(idx._isnan, expected)
+        assert idx.hasnans is True
+
+
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+@pytest.mark.parametrize("na_position", [None, "middle"])
+def test_sort_values_invalid_na_position(index_with_missing, na_position):
+    with pytest.raises(ValueError, match=f"invalid na_position: {na_position}"):
+        index_with_missing.sort_values(na_position=na_position)
+
+
+@pytest.mark.fails_arm_wheels
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+@pytest.mark.parametrize("na_position", ["first", "last"])
+def test_sort_values_with_missing(index_with_missing, na_position, request):
+    # GH 35584. Test that sort_values works with missing values,
+    # sort non-missing and place missing according to na_position
+
+    if isinstance(index_with_missing, CategoricalIndex):
+        request.applymarker(
+            pytest.mark.xfail(
+                reason="missing value sorting order not well-defined", strict=False
+            )
+        )
+
+    missing_count = np.sum(index_with_missing.isna())
+    not_na_vals = index_with_missing[index_with_missing.notna()].values
+    sorted_values = np.sort(not_na_vals)
+    if na_position == "first":
+        sorted_values = np.concatenate([[None] * missing_count, sorted_values])
+    else:
+        sorted_values = np.concatenate([sorted_values, [None] * missing_count])
+
+    # Explicitly pass dtype needed for Index backed by EA e.g. IntegerArray
+    expected = type(index_with_missing)(sorted_values, dtype=index_with_missing.dtype)
+
+    result = index_with_missing.sort_values(na_position=na_position)
+    tm.assert_index_equal(result, expected)
+
+
+def test_ndarray_compat_properties(index):
+    if isinstance(index, PeriodIndex) and not IS64:
+        pytest.skip("Overflow")
+    idx = index
+    assert idx.T.equals(idx)
+    assert idx.transpose().equals(idx)
+
+    values = idx.values
+
+    assert idx.shape == values.shape
+    assert idx.ndim == values.ndim
+    assert idx.size == values.size
+
+    if not isinstance(index, (RangeIndex, MultiIndex)):
+        # These two are not backed by an ndarray
+        assert idx.nbytes == values.nbytes
+
+    # test for validity
+    idx.nbytes
+    idx.values.nbytes
+
+
+def test_compare_read_only_array():
+    # GH#57130
+    arr = np.array([], dtype=object)
+    arr.flags.writeable = False
+    idx = pd.Index(arr)
+    result = idx > 69
+    assert result.dtype == bool

llava_next/lib/python3.10/site-packages/pandas/tests/scalar/period/test_period.py

@@ -0,0 +1,1154 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTHS,
+)
+from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
+from pandas._libs.tslibs.parsing import DateParseError
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+
+from pandas import (
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+
+bday_msg = "Period with BDay freq is deprecated"
+
+
+class TestPeriodDisallowedFreqs:
+    @pytest.mark.parametrize(
+        "freq, freq_msg",
+        [
+            (offsets.BYearBegin(), "BYearBegin"),
+            (offsets.YearBegin(2), "YearBegin"),
+            (offsets.QuarterBegin(startingMonth=12), "QuarterBegin"),
+            (offsets.BusinessMonthEnd(2), "BusinessMonthEnd"),
+        ],
+    )
+    def test_offsets_not_supported(self, freq, freq_msg):
+        # GH#55785
+        msg = re.escape(f"{freq} is not supported as period frequency")
+        with pytest.raises(ValueError, match=msg):
+            Period(year=2014, freq=freq)
+
+    def test_custom_business_day_freq_raises(self):
+        # GH#52534
+        msg = "C is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2023-04-10", freq="C")
+        msg = f"{offsets.CustomBusinessDay().base} is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2023-04-10", freq=offsets.CustomBusinessDay())
+
+    def test_invalid_frequency_error_message(self):
+        msg = "WOM-1MON is not supported as period frequency"
+        with pytest.raises(ValueError, match=msg):
+            Period("2012-01-02", freq="WOM-1MON")
+
+    def test_invalid_frequency_period_error_message(self):
+        msg = "for Period, please use 'M' instead of 'ME'"
+        with pytest.raises(ValueError, match=msg):
+            Period("2012-01-02", freq="ME")
+
+
+class TestPeriodConstruction:
+    def test_from_td64nat_raises(self):
+        # GH#44507
+        td = NaT.to_numpy("m8[ns]")
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(td)
+
+        with pytest.raises(ValueError, match=msg):
+            Period(td, freq="D")
+
+    def test_construction(self):
+        i1 = Period("1/1/2005", freq="M")
+        i2 = Period("Jan 2005")
+
+        assert i1 == i2
+
+        # GH#54105 - Period can be confusingly instantiated with lowercase freq
+        # TODO: raise in the future an error when passing lowercase freq
+        i1 = Period("2005", freq="Y")
+        i2 = Period("2005")
+
+        assert i1 == i2
+
+        i4 = Period("2005", freq="M")
+        assert i1 != i4
+
+        i1 = Period.now(freq="Q")
+        i2 = Period(datetime.now(), freq="Q")
+
+        assert i1 == i2
+
+        # Pass in freq as a keyword argument sometimes as a test for
+        # https://github.com/pandas-dev/pandas/issues/53369
+        i1 = Period.now(freq="D")
+        i2 = Period(datetime.now(), freq="D")
+        i3 = Period.now(offsets.Day())
+
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("1982", freq="min")
+        msg = "'MIN' is deprecated and will be removed in a future version."
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            i2 = Period("1982", freq="MIN")
+        assert i1 == i2
+
+        i1 = Period(year=2005, month=3, day=1, freq="D")
+        i2 = Period("3/1/2005", freq="D")
+        assert i1 == i2
+
+        i3 = Period(year=2005, month=3, day=1, freq="d")
+        assert i1 == i3
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
+        assert i1 == expected
+
+        msg = "Must supply freq for ordinal value"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=200701)
+
+        msg = "Invalid frequency: X"
+        with pytest.raises(ValueError, match=msg):
+            Period("2007-1-1", freq="X")
+
+    def test_tuple_freq_disallowed(self):
+        # GH#34703 tuple freq disallowed
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("1982", freq=("Min", 1))
+
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("2006-12-31", ("w", 1))
+
+    def test_construction_from_timestamp_nanos(self):
+        # GH#46811 don't drop nanos from Timestamp
+        ts = Timestamp("2022-04-20 09:23:24.123456789")
+        per = Period(ts, freq="ns")
+
+        # should losslessly round-trip, not lose the 789
+        rt = per.to_timestamp()
+        assert rt == ts
+
+        # same thing but from a datetime64 object
+        dt64 = ts.asm8
+        per2 = Period(dt64, freq="ns")
+        rt2 = per2.to_timestamp()
+        assert rt2.asm8 == dt64
+
+    def test_construction_bday(self):
+        # Biz day construction, roll forward if non-weekday
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            i1 = Period("3/10/12", freq="B")
+            i2 = Period("3/10/12", freq="D")
+            assert i1 == i2.asfreq("B")
+            i2 = Period("3/11/12", freq="D")
+            assert i1 == i2.asfreq("B")
+            i2 = Period("3/12/12", freq="D")
+            assert i1 == i2.asfreq("B")
+
+            i3 = Period("3/10/12", freq="b")
+            assert i1 == i3
+
+            i1 = Period(year=2012, month=3, day=10, freq="B")
+            i2 = Period("3/12/12", freq="B")
+            assert i1 == i2
+
+    def test_construction_quarter(self):
+        i1 = Period(year=2005, quarter=1, freq="Q")
+        i2 = Period("1/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period(year=2005, quarter=3, freq="Q")
+        i2 = Period("9/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period("2005Q1")
+        i2 = Period(year=2005, quarter=1, freq="Q")
+        i3 = Period("2005q1")
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("05Q1")
+        assert i1 == i2
+        lower = Period("05q1")
+        assert i1 == lower
+
+        i1 = Period("1Q2005")
+        assert i1 == i2
+        lower = Period("1q2005")
+        assert i1 == lower
+
+        i1 = Period("1Q05")
+        assert i1 == i2
+        lower = Period("1q05")
+        assert i1 == lower
+
+        i1 = Period("4Q1984")
+        assert i1.year == 1984
+        lower = Period("4q1984")
+        assert i1 == lower
+
+    def test_construction_month(self):
+        expected = Period("2007-01", freq="M")
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period(200701, freq="M")
+        assert i1 == expected
+
+        i1 = Period(ordinal=200701, freq="M")
+        assert i1.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+    def test_period_constructor_offsets(self):
+        assert Period("1/1/2005", freq=offsets.MonthEnd()) == Period(
+            "1/1/2005", freq="M"
+        )
+        assert Period("2005", freq=offsets.YearEnd()) == Period("2005", freq="Y")
+        assert Period("2005", freq=offsets.MonthEnd()) == Period("2005", freq="M")
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period("3/10/12", freq=offsets.BusinessDay()) == Period(
+                "3/10/12", freq="B"
+            )
+        assert Period("3/10/12", freq=offsets.Day()) == Period("3/10/12", freq="D")
+
+        assert Period(
+            year=2005, quarter=1, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=1, freq="Q")
+        assert Period(
+            year=2005, quarter=2, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=2, freq="Q")
+
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day()) == Period(
+            year=2005, month=3, day=1, freq="D"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(year=2012, month=3, day=10, freq=offsets.BDay()) == Period(
+                year=2012, month=3, day=10, freq="B"
+            )
+
+        expected = Period("2005-03-01", freq="3D")
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day(3)) == expected
+        assert Period(year=2005, month=3, day=1, freq="3D") == expected
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(year=2012, month=3, day=10, freq=offsets.BDay(3)) == Period(
+                year=2012, month=3, day=10, freq="3B"
+            )
+
+        assert Period(200701, freq=offsets.MonthEnd()) == Period(200701, freq="M")
+
+        i1 = Period(ordinal=200701, freq=offsets.MonthEnd())
+        i2 = Period(ordinal=200701, freq="M")
+        assert i1 == i2
+        assert i1.year == 18695
+        assert i2.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="ms")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="ms")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="us")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="us")
+        assert i1 == expected
+
+    def test_invalid_arguments(self):
+        msg = "Must supply freq for datetime value"
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now())
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now().date())
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(1.6, freq="D")
+        msg = "Ordinal must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1.6, freq="D")
+        msg = "Only value or ordinal but not both should be given but not both"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=2, value=1, freq="D")
+
+        msg = "If value is None, freq cannot be None"
+        with pytest.raises(ValueError, match=msg):
+            Period(month=1)
+
+        msg = '^Given date string "-2000" not likely a datetime$'
+        with pytest.raises(ValueError, match=msg):
+            Period("-2000", "Y")
+        msg = "day is out of range for month"
+        with pytest.raises(DateParseError, match=msg):
+            Period("0", "Y")
+        msg = "Unknown datetime string format, unable to parse"
+        with pytest.raises(DateParseError, match=msg):
+            Period("1/1/-2000", "Y")
+
+    def test_constructor_corner(self):
+        expected = Period("2007-01", freq="2M")
+        assert Period(year=2007, month=1, freq="2M") == expected
+
+        assert Period(None) is NaT
+
+        p = Period("2007-01-01", freq="D")
+
+        result = Period(p, freq="Y")
+        exp = Period("2007", freq="Y")
+        assert result == exp
+
+    def test_constructor_infer_freq(self):
+        p = Period("2007-01-01")
+        assert p.freq == "D"
+
+        p = Period("2007-01-01 07")
+        assert p.freq == "h"
+
+        p = Period("2007-01-01 07:10")
+        assert p.freq == "min"
+
+        p = Period("2007-01-01 07:10:15")
+        assert p.freq == "s"
+
+        p = Period("2007-01-01 07:10:15.123")
+        assert p.freq == "ms"
+
+        # We see that there are 6 digits after the decimal, so get microsecond
+        #  even though they are all zeros.
+        p = Period("2007-01-01 07:10:15.123000")
+        assert p.freq == "us"
+
+        p = Period("2007-01-01 07:10:15.123400")
+        assert p.freq == "us"
+
+    def test_multiples(self):
+        result1 = Period("1989", freq="2Y")
+        result2 = Period("1989", freq="Y")
+        assert result1.ordinal == result2.ordinal
+        assert result1.freqstr == "2Y-DEC"
+        assert result2.freqstr == "Y-DEC"
+        assert result1.freq == offsets.YearEnd(2)
+        assert result2.freq == offsets.YearEnd()
+
+        assert (result1 + 1).ordinal == result1.ordinal + 2
+        assert (1 + result1).ordinal == result1.ordinal + 2
+        assert (result1 - 1).ordinal == result2.ordinal - 2
+        assert (-1 + result1).ordinal == result2.ordinal - 2
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_quarterly(self, month):
+        # bugs in scikits.timeseries
+        freq = f"Q-{month}"
+        exp = Period("1989Q3", freq=freq)
+        assert "1989Q3" in str(exp)
+        stamp = exp.to_timestamp("D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+        stamp = exp.to_timestamp("3D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_annual(self, month):
+        # bugs in scikits.timeseries
+        freq = f"Y-{month}"
+        exp = Period("1989", freq=freq)
+        stamp = exp.to_timestamp("D", how="end") + timedelta(days=30)
+        p = Period(stamp, freq=freq)
+
+        assert p == exp + 1
+        assert isinstance(p, Period)
+
+    @pytest.mark.parametrize("day", DAYS)
+    @pytest.mark.parametrize("num", range(10, 17))
+    def test_period_cons_weekly(self, num, day):
+        daystr = f"2011-02-{num}"
+        freq = f"W-{day}"
+
+        result = Period(daystr, freq=freq)
+        expected = Period(daystr, freq="D").asfreq(freq)
+        assert result == expected
+        assert isinstance(result, Period)
+
+    def test_parse_week_str_roundstrip(self):
+        # GH#50803
+        per = Period("2017-01-23/2017-01-29")
+        assert per.freq.freqstr == "W-SUN"
+
+        per = Period("2017-01-24/2017-01-30")
+        assert per.freq.freqstr == "W-MON"
+
+        msg = "Could not parse as weekly-freq Period"
+        with pytest.raises(ValueError, match=msg):
+            # not 6 days apart
+            Period("2016-01-23/2017-01-29")
+
+    def test_period_from_ordinal(self):
+        p = Period("2011-01", freq="M")
+        res = Period._from_ordinal(p.ordinal, freq=p.freq)
+        assert p == res
+        assert isinstance(res, Period)
+
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "h"])
+    def test_construct_from_nat_string_and_freq(self, freq):
+        per = Period("NaT", freq=freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="2" + freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="3" + freq)
+        assert per is NaT
+
+    def test_period_cons_nat(self):
+        p = Period("nat", freq="W-SUN")
+        assert p is NaT
+
+        p = Period(iNaT, freq="D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="3D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="1D1h")
+        assert p is NaT
+
+        p = Period("NaT")
+        assert p is NaT
+
+        p = Period(iNaT)
+        assert p is NaT
+
+    def test_period_cons_mult(self):
+        p1 = Period("2011-01", freq="3M")
+        p2 = Period("2011-01", freq="M")
+        assert p1.ordinal == p2.ordinal
+
+        assert p1.freq == offsets.MonthEnd(3)
+        assert p1.freqstr == "3M"
+
+        assert p2.freq == offsets.MonthEnd()
+        assert p2.freqstr == "M"
+
+        result = p1 + 1
+        assert result.ordinal == (p2 + 3).ordinal
+
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        result = p1 - 1
+        assert result.ordinal == (p2 - 3).ordinal
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        msg = "Frequency must be positive, because it represents span: -3M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-3M")
+
+        msg = "Frequency must be positive, because it represents span: 0M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0M")
+
+    def test_period_cons_combined(self):
+        p = [
+            (
+                Period("2011-01", freq="1D1h"),
+                Period("2011-01", freq="1h1D"),
+                Period("2011-01", freq="h"),
+            ),
+            (
+                Period(ordinal=1, freq="1D1h"),
+                Period(ordinal=1, freq="1h1D"),
+                Period(ordinal=1, freq="h"),
+            ),
+        ]
+
+        for p1, p2, p3 in p:
+            assert p1.ordinal == p3.ordinal
+            assert p2.ordinal == p3.ordinal
+
+            assert p1.freq == offsets.Hour(25)
+            assert p1.freqstr == "25h"
+
+            assert p2.freq == offsets.Hour(25)
+            assert p2.freqstr == "25h"
+
+            assert p3.freq == offsets.Hour()
+            assert p3.freqstr == "h"
+
+            result = p1 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25h"
+
+            result = p2 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25h"
+
+            result = p1 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25h"
+
+            result = p2 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25h"
+
+        msg = "Frequency must be positive, because it represents span: -25h"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1D1h")
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1h1D")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1D1h")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1h1D")
+
+        msg = "Frequency must be positive, because it represents span: 0D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0D0h")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="0D0h")
+
+        # You can only combine together day and intraday offsets
+        msg = "Invalid frequency: 1W1D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1W1D")
+        msg = "Invalid frequency: 1D1W"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1D1W")
+
+    @pytest.mark.parametrize("day", ["1970/01/01 ", "2020-12-31 ", "1981/09/13 "])
+    @pytest.mark.parametrize("hour", ["00:00:00", "00:00:01", "23:59:59", "12:00:59"])
+    @pytest.mark.parametrize(
+        "sec_float, expected",
+        [
+            (".000000001", 1),
+            (".000000999", 999),
+            (".123456789", 789),
+            (".999999999", 999),
+            (".999999000", 0),
+            # Test femtoseconds, attoseconds, picoseconds are dropped like Timestamp
+            (".999999001123", 1),
+            (".999999001123456", 1),
+            (".999999001123456789", 1),
+        ],
+    )
+    def test_period_constructor_nanosecond(self, day, hour, sec_float, expected):
+        # GH 34621
+
+        assert Period(day + hour + sec_float).start_time.nanosecond == expected
+
+    @pytest.mark.parametrize("hour", range(24))
+    def test_period_large_ordinal(self, hour):
+        # Issue #36430
+        # Integer overflow for Period over the maximum timestamp
+        p = Period(ordinal=2562048 + hour, freq="1h")
+        assert p.hour == hour
+
+
+class TestPeriodMethods:
+    def test_round_trip(self):
+        p = Period("2000Q1")
+        new_p = tm.round_trip_pickle(p)
+        assert new_p == p
+
+    def test_hash(self):
+        assert hash(Period("2011-01", freq="M")) == hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01-01", freq="D")) != hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01", freq="3M")) != hash(Period("2011-01", freq="2M"))
+
+        assert hash(Period("2011-01", freq="M")) != hash(Period("2011-02", freq="M"))
+
+    # --------------------------------------------------------------
+    # to_timestamp
+
+    def test_to_timestamp_mult(self):
+        p = Period("2011-01", freq="M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-02-01") - Timedelta(1, "ns")
+        assert p.to_timestamp(how="E") == expected
+
+        p = Period("2011-01", freq="3M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-04-01") - Timedelta(1, "ns")
+        assert p.to_timestamp(how="E") == expected
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_to_timestamp(self):
+        p = Period("1982", freq="Y")
+        start_ts = p.to_timestamp(how="S")
+        aliases = ["s", "StarT", "BEGIn"]
+        for a in aliases:
+            assert start_ts == p.to_timestamp("D", how=a)
+            # freq with mult should not affect to the result
+            assert start_ts == p.to_timestamp("3D", how=a)
+
+        end_ts = p.to_timestamp(how="E")
+        aliases = ["e", "end", "FINIsH"]
+        for a in aliases:
+            assert end_ts == p.to_timestamp("D", how=a)
+            assert end_ts == p.to_timestamp("3D", how=a)
+
+        from_lst = ["Y", "Q", "M", "W", "B", "D", "h", "Min", "s"]
+
+        def _ex(p):
+            if p.freq == "B":
+                return p.start_time + Timedelta(days=1, nanoseconds=-1)
+            return Timestamp((p + p.freq).start_time._value - 1)
+
+        for fcode in from_lst:
+            p = Period("1982", freq=fcode)
+            result = p.to_timestamp().to_period(fcode)
+            assert result == p
+
+            assert p.start_time == p.to_timestamp(how="S")
+
+            assert p.end_time == _ex(p)
+
+        # Frequency other than daily
+
+        p = Period("1985", freq="Y")
+
+        result = p.to_timestamp("h", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+        result = p.to_timestamp("3h", how="end")
+        assert result == expected
+
+        result = p.to_timestamp("min", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+        result = p.to_timestamp("2min", how="end")
+        assert result == expected
+
+        result = p.to_timestamp(how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+
+        expected = datetime(1985, 1, 1)
+        result = p.to_timestamp("h", how="start")
+        assert result == expected
+        result = p.to_timestamp("min", how="start")
+        assert result == expected
+        result = p.to_timestamp("s", how="start")
+        assert result == expected
+        result = p.to_timestamp("3h", how="start")
+        assert result == expected
+        result = p.to_timestamp("5s", how="start")
+        assert result == expected
+
+    def test_to_timestamp_business_end(self):
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per = Period("1990-01-05", "B")  # Friday
+            result = per.to_timestamp("B", how="E")
+
+        expected = Timestamp("1990-01-06") - Timedelta(nanoseconds=1)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "ts, expected",
+        [
+            ("1970-01-01 00:00:00", 0),
+            ("1970-01-01 00:00:00.000001", 1),
+            ("1970-01-01 00:00:00.00001", 10),
+            ("1970-01-01 00:00:00.499", 499000),
+            ("1999-12-31 23:59:59.999", 999000),
+            ("1999-12-31 23:59:59.999999", 999999),
+            ("2050-12-31 23:59:59.5", 500000),
+            ("2050-12-31 23:59:59.500001", 500001),
+            ("2050-12-31 23:59:59.123456", 123456),
+        ],
+    )
+    @pytest.mark.parametrize("freq", [None, "us", "ns"])
+    def test_to_timestamp_microsecond(self, ts, expected, freq):
+        # GH 24444
+        result = Period(ts).to_timestamp(freq=freq).microsecond
+        assert result == expected
+
+    # --------------------------------------------------------------
+    # Rendering: __repr__, strftime, etc
+
+    @pytest.mark.parametrize(
+        "str_ts,freq,str_res,str_freq",
+        (
+            ("Jan-2000", None, "2000-01", "M"),
+            ("2000-12-15", None, "2000-12-15", "D"),
+            (
+                "2000-12-15 13:45:26.123456789",
+                "ns",
+                "2000-12-15 13:45:26.123456789",
+                "ns",
+            ),
+            ("2000-12-15 13:45:26.123456789", "us", "2000-12-15 13:45:26.123456", "us"),
+            ("2000-12-15 13:45:26.123456", None, "2000-12-15 13:45:26.123456", "us"),
+            ("2000-12-15 13:45:26.123456789", "ms", "2000-12-15 13:45:26.123", "ms"),
+            ("2000-12-15 13:45:26.123", None, "2000-12-15 13:45:26.123", "ms"),
+            ("2000-12-15 13:45:26", "s", "2000-12-15 13:45:26", "s"),
+            ("2000-12-15 13:45:26", "min", "2000-12-15 13:45", "min"),
+            ("2000-12-15 13:45:26", "h", "2000-12-15 13:00", "h"),
+            ("2000-12-15", "Y", "2000", "Y-DEC"),
+            ("2000-12-15", "Q", "2000Q4", "Q-DEC"),
+            ("2000-12-15", "M", "2000-12", "M"),
+            ("2000-12-15", "W", "2000-12-11/2000-12-17", "W-SUN"),
+            ("2000-12-15", "D", "2000-12-15", "D"),
+            ("2000-12-15", "B", "2000-12-15", "B"),
+        ),
+    )
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_repr(self, str_ts, freq, str_res, str_freq):
+        p = Period(str_ts, freq=freq)
+        assert str(p) == str_res
+        assert repr(p) == f"Period('{str_res}', '{str_freq}')"
+
+    def test_repr_nat(self):
+        p = Period("nat", freq="M")
+        assert repr(NaT) in repr(p)
+
+    def test_strftime(self):
+        # GH#3363
+        p = Period("2000-1-1 12:34:12", freq="s")
+        res = p.strftime("%Y-%m-%d %H:%M:%S")
+        assert res == "2000-01-01 12:34:12"
+        assert isinstance(res, str)
+
+
+class TestPeriodProperties:
+    """Test properties such as year, month, weekday, etc...."""
+
+    @pytest.mark.parametrize("freq", ["Y", "M", "D", "h"])
+    def test_is_leap_year(self, freq):
+        # GH 13727
+        p = Period("2000-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+        assert isinstance(p.is_leap_year, bool)
+
+        p = Period("1999-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+        p = Period("2004-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+
+        p = Period("2100-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+    def test_quarterly_negative_ordinals(self):
+        p = Period(ordinal=-1, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 4
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 3
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="M")
+        assert p.year == 1969
+        assert p.month == 11
+        assert isinstance(p, Period)
+
+    def test_freq_str(self):
+        i1 = Period("1982", freq="Min")
+        assert i1.freq == offsets.Minute()
+        assert i1.freqstr == "min"
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_period_deprecated_freq(self):
+        cases = {
+            "M": ["MTH", "MONTH", "MONTHLY", "Mth", "month", "monthly"],
+            "B": ["BUS", "BUSINESS", "BUSINESSLY", "WEEKDAY", "bus"],
+            "D": ["DAY", "DLY", "DAILY", "Day", "Dly", "Daily"],
+            "h": ["HR", "HOUR", "HRLY", "HOURLY", "hr", "Hour", "HRly"],
+            "min": ["minute", "MINUTE", "MINUTELY", "minutely"],
+            "s": ["sec", "SEC", "SECOND", "SECONDLY", "second"],
+            "ms": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
+            "us": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
+            "ns": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
+        }
+
+        msg = INVALID_FREQ_ERR_MSG
+        for exp, freqs in cases.items():
+            for freq in freqs:
+                with pytest.raises(ValueError, match=msg):
+                    Period("2016-03-01 09:00", freq=freq)
+                with pytest.raises(ValueError, match=msg):
+                    Period(ordinal=1, freq=freq)
+
+            # check supported freq-aliases still works
+            p1 = Period("2016-03-01 09:00", freq=exp)
+            p2 = Period(ordinal=1, freq=exp)
+            assert isinstance(p1, Period)
+            assert isinstance(p2, Period)
+
+    @staticmethod
+    def _period_constructor(bound, offset):
+        return Period(
+            year=bound.year,
+            month=bound.month,
+            day=bound.day,
+            hour=bound.hour,
+            minute=bound.minute,
+            second=bound.second + offset,
+            freq="us",
+        )
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_outer_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, offset)
+        with pytest.raises(OutOfBoundsDatetime, match="Out of bounds nanosecond"):
+            getattr(period, period_property)
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_inner_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, -offset)
+        expected = period.to_timestamp().round(freq="s")
+        assert getattr(period, period_property).round(freq="s") == expected
+        expected = (bound - offset * Timedelta(1, unit="s")).floor("s")
+        assert getattr(period, period_property).floor("s") == expected
+
+    def test_start_time(self):
+        freq_lst = ["Y", "Q", "M", "D", "h", "min", "s"]
+        xp = datetime(2012, 1, 1)
+        for f in freq_lst:
+            p = Period("2012", freq=f)
+            assert p.start_time == xp
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period("2012", freq="B").start_time == datetime(2012, 1, 2)
+        assert Period("2012", freq="W").start_time == datetime(2011, 12, 26)
+
+    def test_end_time(self):
+        p = Period("2012", freq="Y")
+
+        def _ex(*args):
+            return Timestamp(Timestamp(datetime(*args)).as_unit("ns")._value - 1)
+
+        xp = _ex(2013, 1, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="Q")
+        xp = _ex(2012, 4, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="M")
+        xp = _ex(2012, 2, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="D")
+        xp = _ex(2012, 1, 2)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="h")
+        xp = _ex(2012, 1, 1, 1)
+        assert xp == p.end_time
+
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            p = Period("2012", freq="B")
+            xp = _ex(2012, 1, 3)
+            assert xp == p.end_time
+
+        p = Period("2012", freq="W")
+        xp = _ex(2012, 1, 2)
+        assert xp == p.end_time
+
+        # Test for GH 11738
+        p = Period("2012", freq="15D")
+        xp = _ex(2012, 1, 16)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="1D1h")
+        xp = _ex(2012, 1, 2, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="1h1D")
+        xp = _ex(2012, 1, 2, 1)
+        assert xp == p.end_time
+
+    def test_end_time_business_friday(self):
+        # GH#34449
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            per = Period("1990-01-05", "B")
+            result = per.end_time
+
+        expected = Timestamp("1990-01-06") - Timedelta(nanoseconds=1)
+        assert result == expected
+
+    def test_anchor_week_end_time(self):
+        def _ex(*args):
+            return Timestamp(Timestamp(datetime(*args)).as_unit("ns")._value - 1)
+
+        p = Period("2013-1-1", "W-SAT")
+        xp = _ex(2013, 1, 6)
+        assert p.end_time == xp
+
+    def test_properties_annually(self):
+        # Test properties on Periods with annually frequency.
+        a_date = Period(freq="Y", year=2007)
+        assert a_date.year == 2007
+
+    def test_properties_quarterly(self):
+        # Test properties on Periods with daily frequency.
+        qedec_date = Period(freq="Q-DEC", year=2007, quarter=1)
+        qejan_date = Period(freq="Q-JAN", year=2007, quarter=1)
+        qejun_date = Period(freq="Q-JUN", year=2007, quarter=1)
+        #
+        for x in range(3):
+            for qd in (qedec_date, qejan_date, qejun_date):
+                assert (qd + x).qyear == 2007
+                assert (qd + x).quarter == x + 1
+
+    def test_properties_monthly(self):
+        # Test properties on Periods with daily frequency.
+        m_date = Period(freq="M", year=2007, month=1)
+        for x in range(11):
+            m_ival_x = m_date + x
+            assert m_ival_x.year == 2007
+            if 1 <= x + 1 <= 3:
+                assert m_ival_x.quarter == 1
+            elif 4 <= x + 1 <= 6:
+                assert m_ival_x.quarter == 2
+            elif 7 <= x + 1 <= 9:
+                assert m_ival_x.quarter == 3
+            elif 10 <= x + 1 <= 12:
+                assert m_ival_x.quarter == 4
+            assert m_ival_x.month == x + 1
+
+    def test_properties_weekly(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        #
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+        assert Period(freq="W", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_weekly_legacy(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+
+        exp = Period(freq="W", year=2012, month=2, day=1)
+        assert exp.days_in_month == 29
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK", year=2007, month=1, day=7)
+
+    def test_properties_daily(self):
+        # Test properties on Periods with daily frequency.
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            b_date = Period(freq="B", year=2007, month=1, day=1)
+        #
+        assert b_date.year == 2007
+        assert b_date.quarter == 1
+        assert b_date.month == 1
+        assert b_date.day == 1
+        assert b_date.weekday == 0
+        assert b_date.dayofyear == 1
+        assert b_date.days_in_month == 31
+        with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+            assert Period(freq="B", year=2012, month=2, day=1).days_in_month == 29
+
+        d_date = Period(freq="D", year=2007, month=1, day=1)
+
+        assert d_date.year == 2007
+        assert d_date.quarter == 1
+        assert d_date.month == 1
+        assert d_date.day == 1
+        assert d_date.weekday == 0
+        assert d_date.dayofyear == 1
+        assert d_date.days_in_month == 31
+        assert Period(freq="D", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_hourly(self):
+        # Test properties on Periods with hourly frequency.
+        h_date1 = Period(freq="h", year=2007, month=1, day=1, hour=0)
+        h_date2 = Period(freq="2h", year=2007, month=1, day=1, hour=0)
+
+        for h_date in [h_date1, h_date2]:
+            assert h_date.year == 2007
+            assert h_date.quarter == 1
+            assert h_date.month == 1
+            assert h_date.day == 1
+            assert h_date.weekday == 0
+            assert h_date.dayofyear == 1
+            assert h_date.hour == 0
+            assert h_date.days_in_month == 31
+            assert (
+                Period(freq="h", year=2012, month=2, day=1, hour=0).days_in_month == 29
+            )
+
+    def test_properties_minutely(self):
+        # Test properties on Periods with minutely frequency.
+        t_date = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+        #
+        assert t_date.quarter == 1
+        assert t_date.month == 1
+        assert t_date.day == 1
+        assert t_date.weekday == 0
+        assert t_date.dayofyear == 1
+        assert t_date.hour == 0
+        assert t_date.minute == 0
+        assert t_date.days_in_month == 31
+        assert (
+            Period(freq="D", year=2012, month=2, day=1, hour=0, minute=0).days_in_month
+            == 29
+        )
+
+    def test_properties_secondly(self):
+        # Test properties on Periods with secondly frequency.
+        s_date = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        #
+        assert s_date.year == 2007
+        assert s_date.quarter == 1
+        assert s_date.month == 1
+        assert s_date.day == 1
+        assert s_date.weekday == 0
+        assert s_date.dayofyear == 1
+        assert s_date.hour == 0
+        assert s_date.minute == 0
+        assert s_date.second == 0
+        assert s_date.days_in_month == 31
+        assert (
+            Period(
+                freq="Min", year=2012, month=2, day=1, hour=0, minute=0, second=0
+            ).days_in_month
+            == 29
+        )
+
+
+class TestPeriodComparisons:
+    def test_sort_periods(self):
+        jan = Period("2000-01", "M")
+        feb = Period("2000-02", "M")
+        mar = Period("2000-03", "M")
+        periods = [mar, jan, feb]
+        correctPeriods = [jan, feb, mar]
+        assert sorted(periods) == correctPeriods
+
+
+def test_period_immutable():
+    # see gh-17116
+    msg = "not writable"
+
+    per = Period("2014Q1")
+    with pytest.raises(AttributeError, match=msg):
+        per.ordinal = 14
+
+    freq = per.freq
+    with pytest.raises(AttributeError, match=msg):
+        per.freq = 2 * freq
+
+
+def test_small_year_parsing():
+    per1 = Period("0001-01-07", "D")
+    assert per1.year == 1
+    assert per1.day == 7
+
+
+def test_negone_ordinals():
+    freqs = ["Y", "M", "Q", "D", "h", "min", "s"]
+
+    period = Period(ordinal=-1, freq="D")
+    for freq in freqs:
+        repr(period.asfreq(freq))
+
+    for freq in freqs:
+        period = Period(ordinal=-1, freq=freq)
+        repr(period)
+        assert period.year == 1969
+
+    with tm.assert_produces_warning(FutureWarning, match=bday_msg):
+        period = Period(ordinal=-1, freq="B")
+    repr(period)
+    period = Period(ordinal=-1, freq="W")
+    repr(period)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_freq_code.py

@@ -0,0 +1,69 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    Period,
+    to_offset,
+)
+
+
+@pytest.mark.parametrize(
+    "freqstr,exp_freqstr",
+    [("D", "D"), ("W", "D"), ("ME", "D"), ("s", "s"), ("min", "s"), ("h", "s")],
+)
+def test_get_to_timestamp_base(freqstr, exp_freqstr):
+    off = to_offset(freqstr)
+    per = Period._from_ordinal(1, off)
+    exp_code = to_offset(exp_freqstr)._period_dtype_code
+
+    result_code = per._dtype._get_to_timestamp_base()
+    assert result_code == exp_code
+
+
+@pytest.mark.parametrize(
+    "args,expected",
+    [
+        ((1.5, "min"), (90, "s")),
+        ((62.4, "min"), (3744, "s")),
+        ((1.04, "h"), (3744, "s")),
+        ((1, "D"), (1, "D")),
+        ((0.342931, "h"), (1234551600, "us")),
+        ((1.2345, "D"), (106660800, "ms")),
+    ],
+)
+def test_resolution_bumping(args, expected):
+    # see gh-14378
+    off = to_offset(str(args[0]) + args[1])
+    assert off.n == expected[0]
+    assert off._prefix == expected[1]
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        (0.5, "ns"),
+        # Too much precision in the input can prevent.
+        (0.3429324798798269273987982, "h"),
+    ],
+)
+def test_cat(args):
+    msg = "Invalid frequency"
+
+    with pytest.raises(ValueError, match=msg):
+        to_offset(str(args[0]) + args[1])
+
+
+@pytest.mark.parametrize(
+    "freqstr,expected",
+    [
+        ("1h", "2021-01-01T09:00:00"),
+        ("1D", "2021-01-02T08:00:00"),
+        ("1W", "2021-01-03T08:00:00"),
+        ("1ME", "2021-01-31T08:00:00"),
+        ("1YE", "2021-12-31T08:00:00"),
+    ],
+)
+def test_compatibility(freqstr, expected):
+    ts_np = np.datetime64("2021-01-01T08:00:00.00")
+    do = to_offset(freqstr)
+    assert ts_np + do == np.datetime64(expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_frequencies.py

@@ -0,0 +1,29 @@
+import pytest
+
+from pandas._libs.tslibs import offsets
+
+from pandas.tseries.frequencies import (
+    is_subperiod,
+    is_superperiod,
+)
+
+
+@pytest.mark.parametrize(
+    "p1,p2,expected",
+    [
+        # Input validation.
+        (offsets.MonthEnd(), None, False),
+        (offsets.YearEnd(), None, False),
+        (None, offsets.YearEnd(), False),
+        (None, offsets.MonthEnd(), False),
+        (None, None, False),
+        (offsets.YearEnd(), offsets.MonthEnd(), True),
+        (offsets.Hour(), offsets.Minute(), True),
+        (offsets.Second(), offsets.Milli(), True),
+        (offsets.Milli(), offsets.Micro(), True),
+        (offsets.Micro(), offsets.Nano(), True),
+    ],
+)
+def test_super_sub_symmetry(p1, p2, expected):
+    assert is_superperiod(p1, p2) is expected
+    assert is_subperiod(p2, p1) is expected

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/frequencies/test_inference.py

@@ -0,0 +1,558 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTHS,
+)
+from pandas._libs.tslibs.offsets import _get_offset
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+from pandas.compat import is_platform_windows
+
+from pandas import (
+    DatetimeIndex,
+    Index,
+    RangeIndex,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
+from pandas.core.tools.datetimes import to_datetime
+
+from pandas.tseries import (
+    frequencies,
+    offsets,
+)
+
+
+@pytest.fixture(
+    params=[
+        (timedelta(1), "D"),
+        (timedelta(hours=1), "h"),
+        (timedelta(minutes=1), "min"),
+        (timedelta(seconds=1), "s"),
+        (np.timedelta64(1, "ns"), "ns"),
+        (timedelta(microseconds=1), "us"),
+        (timedelta(microseconds=1000), "ms"),
+    ]
+)
+def base_delta_code_pair(request):
+    return request.param
+
+
+freqs = (
+    [f"QE-{month}" for month in MONTHS]
+    + [f"{annual}-{month}" for annual in ["YE", "BYE"] for month in MONTHS]
+    + ["ME", "BME", "BMS"]
+    + [f"WOM-{count}{day}" for count in range(1, 5) for day in DAYS]
+    + [f"W-{day}" for day in DAYS]
+)
+
+
+@pytest.mark.parametrize("freq", freqs)
+@pytest.mark.parametrize("periods", [5, 7])
+def test_infer_freq_range(periods, freq):
+    freq = freq.upper()
+
+    gen = date_range("1/1/2000", periods=periods, freq=freq)
+    index = DatetimeIndex(gen.values)
+
+    if not freq.startswith("QE-"):
+        assert frequencies.infer_freq(index) == gen.freqstr
+    else:
+        inf_freq = frequencies.infer_freq(index)
+        is_dec_range = inf_freq == "QE-DEC" and gen.freqstr in (
+            "QE",
+            "QE-DEC",
+            "QE-SEP",
+            "QE-JUN",
+            "QE-MAR",
+        )
+        is_nov_range = inf_freq == "QE-NOV" and gen.freqstr in (
+            "QE-NOV",
+            "QE-AUG",
+            "QE-MAY",
+            "QE-FEB",
+        )
+        is_oct_range = inf_freq == "QE-OCT" and gen.freqstr in (
+            "QE-OCT",
+            "QE-JUL",
+            "QE-APR",
+            "QE-JAN",
+        )
+        assert is_dec_range or is_nov_range or is_oct_range
+
+
+def test_raise_if_period_index():
+    index = period_range(start="1/1/1990", periods=20, freq="M")
+    msg = "Check the `freq` attribute instead of using infer_freq"
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(index)
+
+
+def test_raise_if_too_few():
+    index = DatetimeIndex(["12/31/1998", "1/3/1999"])
+    msg = "Need at least 3 dates to infer frequency"
+
+    with pytest.raises(ValueError, match=msg):
+        frequencies.infer_freq(index)
+
+
+def test_business_daily():
+    index = DatetimeIndex(["01/01/1999", "1/4/1999", "1/5/1999"])
+    assert frequencies.infer_freq(index) == "B"
+
+
+def test_business_daily_look_alike():
+    # see gh-16624
+    #
+    # Do not infer "B when "weekend" (2-day gap) in wrong place.
+    index = DatetimeIndex(["12/31/1998", "1/3/1999", "1/4/1999"])
+    assert frequencies.infer_freq(index) is None
+
+
+def test_day_corner():
+    index = DatetimeIndex(["1/1/2000", "1/2/2000", "1/3/2000"])
+    assert frequencies.infer_freq(index) == "D"
+
+
+def test_non_datetime_index():
+    dates = to_datetime(["1/1/2000", "1/2/2000", "1/3/2000"])
+    assert frequencies.infer_freq(dates) == "D"
+
+
+def test_fifth_week_of_month_infer():
+    # see gh-9425
+    #
+    # Only attempt to infer up to WOM-4.
+    index = DatetimeIndex(["2014-03-31", "2014-06-30", "2015-03-30"])
+    assert frequencies.infer_freq(index) is None
+
+
+def test_week_of_month_fake():
+    # All of these dates are on same day
+    # of week and are 4 or 5 weeks apart.
+    index = DatetimeIndex(["2013-08-27", "2013-10-01", "2013-10-29", "2013-11-26"])
+    assert frequencies.infer_freq(index) != "WOM-4TUE"
+
+
+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"
+    )
+
+    with pytest.raises(ValueError, match=msg):
+        date_range("2014-01-01", freq="WOM-5MON")
+
+
+def test_monthly_ambiguous():
+    rng = DatetimeIndex(["1/31/2000", "2/29/2000", "3/31/2000"])
+    assert rng.inferred_freq == "ME"
+
+
+def test_annual_ambiguous():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    assert rng.inferred_freq == "YE-JAN"
+
+
+@pytest.mark.parametrize("count", range(1, 5))
+def test_infer_freq_delta(base_delta_code_pair, count):
+    b = Timestamp(datetime.now())
+    base_delta, code = base_delta_code_pair
+
+    inc = base_delta * count
+    index = DatetimeIndex([b + inc * j for j in range(3)])
+
+    exp_freq = f"{count:d}{code}" if count > 1 else code
+    assert frequencies.infer_freq(index) == exp_freq
+
+
+@pytest.mark.parametrize(
+    "constructor",
+    [
+        lambda now, delta: DatetimeIndex(
+            [now + delta * 7] + [now + delta * j for j in range(3)]
+        ),
+        lambda now, delta: DatetimeIndex(
+            [now + delta * j for j in range(3)] + [now + delta * 7]
+        ),
+    ],
+)
+def test_infer_freq_custom(base_delta_code_pair, constructor):
+    b = Timestamp(datetime.now())
+    base_delta, _ = base_delta_code_pair
+
+    index = constructor(b, base_delta)
+    assert frequencies.infer_freq(index) is None
+
+
+@pytest.mark.parametrize(
+    "freq,expected", [("Q", "QE-DEC"), ("Q-NOV", "QE-NOV"), ("Q-OCT", "QE-OCT")]
+)
+def test_infer_freq_index(freq, expected):
+    rng = period_range("1959Q2", "2009Q3", freq=freq)
+    with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+        rng = Index(rng.to_timestamp("D", how="e").astype(object))
+
+    assert rng.inferred_freq == expected
+
+
+@pytest.mark.parametrize(
+    "expected,dates",
+    list(
+        {
+            "YS-JAN": ["2009-01-01", "2010-01-01", "2011-01-01", "2012-01-01"],
+            "QE-OCT": ["2009-01-31", "2009-04-30", "2009-07-31", "2009-10-31"],
+            "ME": ["2010-11-30", "2010-12-31", "2011-01-31", "2011-02-28"],
+            "W-SAT": ["2010-12-25", "2011-01-01", "2011-01-08", "2011-01-15"],
+            "D": ["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"],
+            "h": [
+                "2011-12-31 22:00",
+                "2011-12-31 23:00",
+                "2012-01-01 00:00",
+                "2012-01-01 01:00",
+            ],
+        }.items()
+    ),
+)
+@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+def test_infer_freq_tz(tz_naive_fixture, expected, dates, unit):
+    # see gh-7310, GH#55609
+    tz = tz_naive_fixture
+    idx = DatetimeIndex(dates, tz=tz).as_unit(unit)
+    assert idx.inferred_freq == expected
+
+
+def test_infer_freq_tz_series(tz_naive_fixture):
+    # infer_freq should work with both tz-naive and tz-aware series. See gh-52456
+    tz = tz_naive_fixture
+    idx = date_range("2021-01-01", "2021-01-04", tz=tz)
+    series = idx.to_series().reset_index(drop=True)
+    inferred_freq = frequencies.infer_freq(series)
+    assert inferred_freq == "D"
+
+
+@pytest.mark.parametrize(
+    "date_pair",
+    [
+        ["2013-11-02", "2013-11-5"],  # Fall DST
+        ["2014-03-08", "2014-03-11"],  # Spring DST
+        ["2014-01-01", "2014-01-03"],  # Regular Time
+    ],
+)
+@pytest.mark.parametrize(
+    "freq",
+    ["h", "3h", "10min", "3601s", "3600001ms", "3600000001us", "3600000000001ns"],
+)
+def test_infer_freq_tz_transition(tz_naive_fixture, date_pair, freq):
+    # see gh-8772
+    tz = tz_naive_fixture
+    idx = date_range(date_pair[0], date_pair[1], freq=freq, tz=tz)
+    assert idx.inferred_freq == freq
+
+
+def test_infer_freq_tz_transition_custom():
+    index = date_range("2013-11-03", periods=5, freq="3h").tz_localize(
+        "America/Chicago"
+    )
+    assert index.inferred_freq is None
+
+
+@pytest.mark.parametrize(
+    "data,expected",
+    [
+        # Hourly freq in a day must result in "h"
+        (
+            [
+                "2014-07-01 09:00",
+                "2014-07-01 10:00",
+                "2014-07-01 11:00",
+                "2014-07-01 12:00",
+                "2014-07-01 13:00",
+                "2014-07-01 14:00",
+            ],
+            "h",
+        ),
+        (
+            [
+                "2014-07-01 09:00",
+                "2014-07-01 10:00",
+                "2014-07-01 11:00",
+                "2014-07-01 12:00",
+                "2014-07-01 13:00",
+                "2014-07-01 14:00",
+                "2014-07-01 15:00",
+                "2014-07-01 16:00",
+                "2014-07-02 09:00",
+                "2014-07-02 10:00",
+                "2014-07-02 11:00",
+            ],
+            "bh",
+        ),
+        (
+            [
+                "2014-07-04 09:00",
+                "2014-07-04 10:00",
+                "2014-07-04 11:00",
+                "2014-07-04 12:00",
+                "2014-07-04 13:00",
+                "2014-07-04 14:00",
+                "2014-07-04 15:00",
+                "2014-07-04 16:00",
+                "2014-07-07 09:00",
+                "2014-07-07 10:00",
+                "2014-07-07 11:00",
+            ],
+            "bh",
+        ),
+        (
+            [
+                "2014-07-04 09:00",
+                "2014-07-04 10:00",
+                "2014-07-04 11:00",
+                "2014-07-04 12:00",
+                "2014-07-04 13:00",
+                "2014-07-04 14:00",
+                "2014-07-04 15:00",
+                "2014-07-04 16:00",
+                "2014-07-07 09:00",
+                "2014-07-07 10:00",
+                "2014-07-07 11:00",
+                "2014-07-07 12:00",
+                "2014-07-07 13:00",
+                "2014-07-07 14:00",
+                "2014-07-07 15:00",
+                "2014-07-07 16:00",
+                "2014-07-08 09:00",
+                "2014-07-08 10:00",
+                "2014-07-08 11:00",
+                "2014-07-08 12:00",
+                "2014-07-08 13:00",
+                "2014-07-08 14:00",
+                "2014-07-08 15:00",
+                "2014-07-08 16:00",
+            ],
+            "bh",
+        ),
+    ],
+)
+def test_infer_freq_business_hour(data, expected):
+    # see gh-7905
+    idx = DatetimeIndex(data)
+    assert idx.inferred_freq == expected
+
+
+def test_not_monotonic():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    rng = rng[::-1]
+
+    assert rng.inferred_freq == "-1YE-JAN"
+
+
+def test_non_datetime_index2():
+    rng = DatetimeIndex(["1/31/2000", "1/31/2001", "1/31/2002"])
+    vals = rng.to_pydatetime()
+
+    result = frequencies.infer_freq(vals)
+    assert result == rng.inferred_freq
+
+
+@pytest.mark.parametrize(
+    "idx",
+    [
+        Index(np.arange(5), dtype=np.int64),
+        Index(np.arange(5), dtype=np.float64),
+        period_range("2020-01-01", periods=5),
+        RangeIndex(5),
+    ],
+)
+def test_invalid_index_types(idx):
+    # see gh-48439
+    msg = "|".join(
+        [
+            "cannot infer freq from a non-convertible",
+            "Check the `freq` attribute instead of using infer_freq",
+        ]
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(idx)
+
+
+@pytest.mark.skipif(is_platform_windows(), reason="see gh-10822: Windows issue")
+def test_invalid_index_types_unicode():
+    # see gh-10822
+    #
+    # Odd error message on conversions to datetime for unicode.
+    msg = "Unknown datetime string format"
+
+    with pytest.raises(ValueError, match=msg):
+        frequencies.infer_freq(Index(["ZqgszYBfuL"]))
+
+
+def test_string_datetime_like_compat():
+    # see gh-6463
+    data = ["2004-01", "2004-02", "2004-03", "2004-04"]
+
+    expected = frequencies.infer_freq(data)
+    result = frequencies.infer_freq(Index(data))
+
+    assert result == expected
+
+
+def test_series():
+    # see gh-6407
+    s = Series(date_range("20130101", "20130110"))
+    inferred = frequencies.infer_freq(s)
+    assert inferred == "D"
+
+
+@pytest.mark.parametrize("end", [10, 10.0])
+def test_series_invalid_type(end):
+    # see gh-6407
+    msg = "cannot infer freq from a non-convertible dtype on a Series"
+    s = Series(np.arange(end))
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(s)
+
+
+def test_series_inconvertible_string(using_infer_string):
+    # see gh-6407
+    if using_infer_string:
+        msg = "cannot infer freq from"
+
+        with pytest.raises(TypeError, match=msg):
+            frequencies.infer_freq(Series(["foo", "bar"]))
+    else:
+        msg = "Unknown datetime string format"
+
+        with pytest.raises(ValueError, match=msg):
+            frequencies.infer_freq(Series(["foo", "bar"]))
+
+
+@pytest.mark.parametrize("freq", [None, "ms"])
+def test_series_period_index(freq):
+    # see gh-6407
+    #
+    # Cannot infer on PeriodIndex
+    msg = "cannot infer freq from a non-convertible dtype on a Series"
+    s = Series(period_range("2013", periods=10, freq=freq))
+
+    with pytest.raises(TypeError, match=msg):
+        frequencies.infer_freq(s)
+
+
+@pytest.mark.parametrize("freq", ["ME", "ms", "s"])
+def test_series_datetime_index(freq):
+    s = Series(date_range("20130101", periods=10, freq=freq))
+    inferred = frequencies.infer_freq(s)
+    assert inferred == freq
+
+
+@pytest.mark.parametrize(
+    "offset_func",
+    [
+        _get_offset,
+        lambda freq: date_range("2011-01-01", periods=5, freq=freq),
+    ],
+)
+@pytest.mark.parametrize(
+    "freq",
+    [
+        "WEEKDAY",
+        "EOM",
+        "W@MON",
+        "W@TUE",
+        "W@WED",
+        "W@THU",
+        "W@FRI",
+        "W@SAT",
+        "W@SUN",
+        "QE@JAN",
+        "QE@FEB",
+        "QE@MAR",
+        "YE@JAN",
+        "YE@FEB",
+        "YE@MAR",
+        "YE@APR",
+        "YE@MAY",
+        "YE@JUN",
+        "YE@JUL",
+        "YE@AUG",
+        "YE@SEP",
+        "YE@OCT",
+        "YE@NOV",
+        "YE@DEC",
+        "YE@JAN",
+        "WOM@1MON",
+        "WOM@2MON",
+        "WOM@3MON",
+        "WOM@4MON",
+        "WOM@1TUE",
+        "WOM@2TUE",
+        "WOM@3TUE",
+        "WOM@4TUE",
+        "WOM@1WED",
+        "WOM@2WED",
+        "WOM@3WED",
+        "WOM@4WED",
+        "WOM@1THU",
+        "WOM@2THU",
+        "WOM@3THU",
+        "WOM@4THU",
+        "WOM@1FRI",
+        "WOM@2FRI",
+        "WOM@3FRI",
+        "WOM@4FRI",
+    ],
+)
+def test_legacy_offset_warnings(offset_func, freq):
+    with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+        offset_func(freq)
+
+
+def test_ms_vs_capital_ms():
+    left = _get_offset("ms")
+    right = _get_offset("MS")
+
+    assert left == offsets.Milli()
+    assert right == offsets.MonthBegin()
+
+
+def test_infer_freq_non_nano():
+    arr = np.arange(10).astype(np.int64).view("M8[s]")
+    dta = DatetimeArray._simple_new(arr, dtype=arr.dtype)
+    res = frequencies.infer_freq(dta)
+    assert res == "s"
+
+    arr2 = arr.view("m8[ms]")
+    tda = TimedeltaArray._simple_new(arr2, dtype=arr2.dtype)
+    res2 = frequencies.infer_freq(tda)
+    assert res2 == "ms"
+
+
+def test_infer_freq_non_nano_tzaware(tz_aware_fixture):
+    tz = tz_aware_fixture
+
+    dti = date_range("2016-01-01", periods=365, freq="B", tz=tz)
+    dta = dti._data.as_unit("s")
+
+    res = frequencies.infer_freq(dta)
+    assert res == "B"

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/holiday/test_calendar.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    offsets,
+    to_datetime,
+)
+import pandas._testing as tm
+
+from pandas.tseries.holiday import (
+    AbstractHolidayCalendar,
+    Holiday,
+    Timestamp,
+    USFederalHolidayCalendar,
+    USLaborDay,
+    USThanksgivingDay,
+    get_calendar,
+)
+
+
+@pytest.mark.parametrize(
+    "transform", [lambda x: x, lambda x: x.strftime("%Y-%m-%d"), lambda x: Timestamp(x)]
+)
+def test_calendar(transform):
+    start_date = datetime(2012, 1, 1)
+    end_date = datetime(2012, 12, 31)
+
+    calendar = USFederalHolidayCalendar()
+    holidays = calendar.holidays(transform(start_date), transform(end_date))
+
+    expected = [
+        datetime(2012, 1, 2),
+        datetime(2012, 1, 16),
+        datetime(2012, 2, 20),
+        datetime(2012, 5, 28),
+        datetime(2012, 7, 4),
+        datetime(2012, 9, 3),
+        datetime(2012, 10, 8),
+        datetime(2012, 11, 12),
+        datetime(2012, 11, 22),
+        datetime(2012, 12, 25),
+    ]
+
+    assert list(holidays.to_pydatetime()) == expected
+
+
+def test_calendar_caching():
+    # see gh-9552.
+
+    class TestCalendar(AbstractHolidayCalendar):
+        def __init__(self, name=None, rules=None) -> None:
+            super().__init__(name=name, rules=rules)
+
+    jan1 = TestCalendar(rules=[Holiday("jan1", year=2015, month=1, day=1)])
+    jan2 = TestCalendar(rules=[Holiday("jan2", year=2015, month=1, day=2)])
+
+    # Getting holidays for Jan 1 should not alter results for Jan 2.
+    expected = DatetimeIndex(["01-Jan-2015"]).as_unit("ns")
+    tm.assert_index_equal(jan1.holidays(), expected)
+
+    expected2 = DatetimeIndex(["02-Jan-2015"]).as_unit("ns")
+    tm.assert_index_equal(jan2.holidays(), expected2)
+
+
+def test_calendar_observance_dates():
+    # see gh-11477
+    us_fed_cal = get_calendar("USFederalHolidayCalendar")
+    holidays0 = us_fed_cal.holidays(
+        datetime(2015, 7, 3), datetime(2015, 7, 3)
+    )  # <-- same start and end dates
+    holidays1 = us_fed_cal.holidays(
+        datetime(2015, 7, 3), datetime(2015, 7, 6)
+    )  # <-- different start and end dates
+    holidays2 = us_fed_cal.holidays(
+        datetime(2015, 7, 3), datetime(2015, 7, 3)
+    )  # <-- same start and end dates
+
+    # These should all produce the same result.
+    #
+    # In addition, calling with different start and end
+    # dates should not alter the output if we call the
+    # function again with the same start and end date.
+    tm.assert_index_equal(holidays0, holidays1)
+    tm.assert_index_equal(holidays0, holidays2)
+
+
+def test_rule_from_name():
+    us_fed_cal = get_calendar("USFederalHolidayCalendar")
+    assert us_fed_cal.rule_from_name("Thanksgiving Day") == USThanksgivingDay
+
+
+def test_calendar_2031():
+    # See gh-27790
+    #
+    # Labor Day 2031 is on September 1. Saturday before is August 30.
+    # Next working day after August 30 ought to be Tuesday, September 2.
+
+    class testCalendar(AbstractHolidayCalendar):
+        rules = [USLaborDay]
+
+    cal = testCalendar()
+    workDay = offsets.CustomBusinessDay(calendar=cal)
+    Sat_before_Labor_Day_2031 = to_datetime("2031-08-30")
+    next_working_day = Sat_before_Labor_Day_2031 + 0 * workDay
+    assert next_working_day == to_datetime("2031-09-02")
+
+
+def test_no_holidays_calendar():
+    # Test for issue #31415
+
+    class NoHolidaysCalendar(AbstractHolidayCalendar):
+        pass
+
+    cal = NoHolidaysCalendar()
+    holidays = cal.holidays(Timestamp("01-Jan-2020"), Timestamp("01-Jan-2021"))
+    empty_index = DatetimeIndex([])  # Type is DatetimeIndex since return_name=False
+    tm.assert_index_equal(holidays, empty_index)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/holiday/test_federal.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+
+from pandas import DatetimeIndex
+import pandas._testing as tm
+
+from pandas.tseries.holiday import (
+    AbstractHolidayCalendar,
+    USFederalHolidayCalendar,
+    USMartinLutherKingJr,
+    USMemorialDay,
+)
+
+
+def test_no_mlk_before_1986():
+    # see gh-10278
+    class MLKCalendar(AbstractHolidayCalendar):
+        rules = [USMartinLutherKingJr]
+
+    holidays = MLKCalendar().holidays(start="1984", end="1988").to_pydatetime().tolist()
+
+    # Testing to make sure holiday is not incorrectly observed before 1986.
+    assert holidays == [datetime(1986, 1, 20, 0, 0), datetime(1987, 1, 19, 0, 0)]
+
+
+def test_memorial_day():
+    class MemorialDay(AbstractHolidayCalendar):
+        rules = [USMemorialDay]
+
+    holidays = MemorialDay().holidays(start="1971", end="1980").to_pydatetime().tolist()
+
+    # Fixes 5/31 error and checked manually against Wikipedia.
+    assert holidays == [
+        datetime(1971, 5, 31, 0, 0),
+        datetime(1972, 5, 29, 0, 0),
+        datetime(1973, 5, 28, 0, 0),
+        datetime(1974, 5, 27, 0, 0),
+        datetime(1975, 5, 26, 0, 0),
+        datetime(1976, 5, 31, 0, 0),
+        datetime(1977, 5, 30, 0, 0),
+        datetime(1978, 5, 29, 0, 0),
+        datetime(1979, 5, 28, 0, 0),
+    ]
+
+
+def test_federal_holiday_inconsistent_returntype():
+    # GH 49075 test case
+    # Instantiate two calendars to rule out _cache
+    cal1 = USFederalHolidayCalendar()
+    cal2 = USFederalHolidayCalendar()
+
+    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)
+
+    # Check against expected results to ensure both date
+    # ranges generate expected results as per GH49075 submission
+    tm.assert_index_equal(results_2018, expected_results)
+    tm.assert_index_equal(results_2019, expected_results)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/holiday/test_holiday.py

@@ -0,0 +1,332 @@
+from datetime import datetime
+
+import pytest
+from pytz import utc
+
+from pandas import (
+    DatetimeIndex,
+    Series,
+)
+import pandas._testing as tm
+
+from pandas.tseries.holiday import (
+    MO,
+    SA,
+    AbstractHolidayCalendar,
+    DateOffset,
+    EasterMonday,
+    GoodFriday,
+    Holiday,
+    HolidayCalendarFactory,
+    Timestamp,
+    USColumbusDay,
+    USFederalHolidayCalendar,
+    USLaborDay,
+    USMartinLutherKingJr,
+    USMemorialDay,
+    USPresidentsDay,
+    USThanksgivingDay,
+    get_calendar,
+    next_monday,
+)
+
+
+@pytest.mark.parametrize(
+    "holiday,start_date,end_date,expected",
+    [
+        (
+            USMemorialDay,
+            datetime(2011, 1, 1),
+            datetime(2020, 12, 31),
+            [
+                datetime(2011, 5, 30),
+                datetime(2012, 5, 28),
+                datetime(2013, 5, 27),
+                datetime(2014, 5, 26),
+                datetime(2015, 5, 25),
+                datetime(2016, 5, 30),
+                datetime(2017, 5, 29),
+                datetime(2018, 5, 28),
+                datetime(2019, 5, 27),
+                datetime(2020, 5, 25),
+            ],
+        ),
+        (
+            Holiday("July 4th Eve", month=7, day=3),
+            "2001-01-01",
+            "2003-03-03",
+            [Timestamp("2001-07-03 00:00:00"), Timestamp("2002-07-03 00:00:00")],
+        ),
+        (
+            Holiday("July 4th Eve", month=7, day=3, days_of_week=(0, 1, 2, 3)),
+            "2001-01-01",
+            "2008-03-03",
+            [
+                Timestamp("2001-07-03 00:00:00"),
+                Timestamp("2002-07-03 00:00:00"),
+                Timestamp("2003-07-03 00:00:00"),
+                Timestamp("2006-07-03 00:00:00"),
+                Timestamp("2007-07-03 00:00:00"),
+            ],
+        ),
+        (
+            EasterMonday,
+            datetime(2011, 1, 1),
+            datetime(2020, 12, 31),
+            [
+                Timestamp("2011-04-25 00:00:00"),
+                Timestamp("2012-04-09 00:00:00"),
+                Timestamp("2013-04-01 00:00:00"),
+                Timestamp("2014-04-21 00:00:00"),
+                Timestamp("2015-04-06 00:00:00"),
+                Timestamp("2016-03-28 00:00:00"),
+                Timestamp("2017-04-17 00:00:00"),
+                Timestamp("2018-04-02 00:00:00"),
+                Timestamp("2019-04-22 00:00:00"),
+                Timestamp("2020-04-13 00:00:00"),
+            ],
+        ),
+        (
+            GoodFriday,
+            datetime(2011, 1, 1),
+            datetime(2020, 12, 31),
+            [
+                Timestamp("2011-04-22 00:00:00"),
+                Timestamp("2012-04-06 00:00:00"),
+                Timestamp("2013-03-29 00:00:00"),
+                Timestamp("2014-04-18 00:00:00"),
+                Timestamp("2015-04-03 00:00:00"),
+                Timestamp("2016-03-25 00:00:00"),
+                Timestamp("2017-04-14 00:00:00"),
+                Timestamp("2018-03-30 00:00:00"),
+                Timestamp("2019-04-19 00:00:00"),
+                Timestamp("2020-04-10 00:00:00"),
+            ],
+        ),
+        (
+            USThanksgivingDay,
+            datetime(2011, 1, 1),
+            datetime(2020, 12, 31),
+            [
+                datetime(2011, 11, 24),
+                datetime(2012, 11, 22),
+                datetime(2013, 11, 28),
+                datetime(2014, 11, 27),
+                datetime(2015, 11, 26),
+                datetime(2016, 11, 24),
+                datetime(2017, 11, 23),
+                datetime(2018, 11, 22),
+                datetime(2019, 11, 28),
+                datetime(2020, 11, 26),
+            ],
+        ),
+    ],
+)
+def test_holiday_dates(holiday, start_date, end_date, expected):
+    assert list(holiday.dates(start_date, end_date)) == expected
+
+    # Verify that timezone info is preserved.
+    assert list(
+        holiday.dates(
+            utc.localize(Timestamp(start_date)), utc.localize(Timestamp(end_date))
+        )
+    ) == [utc.localize(dt) for dt in expected]
+
+
+@pytest.mark.parametrize(
+    "holiday,start,expected",
+    [
+        (USMemorialDay, datetime(2015, 7, 1), []),
+        (USMemorialDay, "2015-05-25", [Timestamp("2015-05-25")]),
+        (USLaborDay, datetime(2015, 7, 1), []),
+        (USLaborDay, "2015-09-07", [Timestamp("2015-09-07")]),
+        (USColumbusDay, datetime(2015, 7, 1), []),
+        (USColumbusDay, "2015-10-12", [Timestamp("2015-10-12")]),
+        (USThanksgivingDay, datetime(2015, 7, 1), []),
+        (USThanksgivingDay, "2015-11-26", [Timestamp("2015-11-26")]),
+        (USMartinLutherKingJr, datetime(2015, 7, 1), []),
+        (USMartinLutherKingJr, "2015-01-19", [Timestamp("2015-01-19")]),
+        (USPresidentsDay, datetime(2015, 7, 1), []),
+        (USPresidentsDay, "2015-02-16", [Timestamp("2015-02-16")]),
+        (GoodFriday, datetime(2015, 7, 1), []),
+        (GoodFriday, "2015-04-03", [Timestamp("2015-04-03")]),
+        (EasterMonday, "2015-04-06", [Timestamp("2015-04-06")]),
+        (EasterMonday, datetime(2015, 7, 1), []),
+        (EasterMonday, "2015-04-05", []),
+        ("New Year's Day", "2015-01-01", [Timestamp("2015-01-01")]),
+        ("New Year's Day", "2010-12-31", [Timestamp("2010-12-31")]),
+        ("New Year's Day", datetime(2015, 7, 1), []),
+        ("New Year's Day", "2011-01-01", []),
+        ("Independence Day", "2015-07-03", [Timestamp("2015-07-03")]),
+        ("Independence Day", datetime(2015, 7, 1), []),
+        ("Independence Day", "2015-07-04", []),
+        ("Veterans Day", "2012-11-12", [Timestamp("2012-11-12")]),
+        ("Veterans Day", datetime(2015, 7, 1), []),
+        ("Veterans Day", "2012-11-11", []),
+        ("Christmas Day", "2011-12-26", [Timestamp("2011-12-26")]),
+        ("Christmas Day", datetime(2015, 7, 1), []),
+        ("Christmas Day", "2011-12-25", []),
+        ("Juneteenth National Independence Day", "2020-06-19", []),
+        (
+            "Juneteenth National Independence Day",
+            "2021-06-18",
+            [Timestamp("2021-06-18")],
+        ),
+        ("Juneteenth National Independence Day", "2022-06-19", []),
+        (
+            "Juneteenth National Independence Day",
+            "2022-06-20",
+            [Timestamp("2022-06-20")],
+        ),
+    ],
+)
+def test_holidays_within_dates(holiday, start, expected):
+    # see gh-11477
+    #
+    # Fix holiday behavior where holiday.dates returned dates outside
+    # start/end date, or observed rules could not be applied because the
+    # holiday was not in the original date range (e.g., 7/4/2015 -> 7/3/2015).
+    if isinstance(holiday, str):
+        calendar = get_calendar("USFederalHolidayCalendar")
+        holiday = calendar.rule_from_name(holiday)
+
+    assert list(holiday.dates(start, start)) == expected
+
+    # Verify that timezone info is preserved.
+    assert list(
+        holiday.dates(utc.localize(Timestamp(start)), utc.localize(Timestamp(start)))
+    ) == [utc.localize(dt) for dt in expected]
+
+
+@pytest.mark.parametrize(
+    "transform", [lambda x: x.strftime("%Y-%m-%d"), lambda x: Timestamp(x)]
+)
+def test_argument_types(transform):
+    start_date = datetime(2011, 1, 1)
+    end_date = datetime(2020, 12, 31)
+
+    holidays = USThanksgivingDay.dates(start_date, end_date)
+    holidays2 = USThanksgivingDay.dates(transform(start_date), transform(end_date))
+    tm.assert_index_equal(holidays, holidays2)
+
+
+@pytest.mark.parametrize(
+    "name,kwargs",
+    [
+        ("One-Time", {"year": 2012, "month": 5, "day": 28}),
+        (
+            "Range",
+            {
+                "month": 5,
+                "day": 28,
+                "start_date": datetime(2012, 1, 1),
+                "end_date": datetime(2012, 12, 31),
+                "offset": DateOffset(weekday=MO(1)),
+            },
+        ),
+    ],
+)
+def test_special_holidays(name, kwargs):
+    base_date = [datetime(2012, 5, 28)]
+    holiday = Holiday(name, **kwargs)
+
+    start_date = datetime(2011, 1, 1)
+    end_date = datetime(2020, 12, 31)
+
+    assert base_date == holiday.dates(start_date, end_date)
+
+
+def test_get_calendar():
+    class TestCalendar(AbstractHolidayCalendar):
+        rules = []
+
+    calendar = get_calendar("TestCalendar")
+    assert TestCalendar == type(calendar)
+
+
+def test_factory():
+    class_1 = HolidayCalendarFactory(
+        "MemorialDay", AbstractHolidayCalendar, USMemorialDay
+    )
+    class_2 = HolidayCalendarFactory(
+        "Thanksgiving", AbstractHolidayCalendar, USThanksgivingDay
+    )
+    class_3 = HolidayCalendarFactory("Combined", class_1, class_2)
+
+    assert len(class_1.rules) == 1
+    assert len(class_2.rules) == 1
+    assert len(class_3.rules) == 2
+
+
+def test_both_offset_observance_raises():
+    # see gh-10217
+    msg = "Cannot use both offset and observance"
+    with pytest.raises(NotImplementedError, match=msg):
+        Holiday(
+            "Cyber Monday",
+            month=11,
+            day=1,
+            offset=[DateOffset(weekday=SA(4))],
+            observance=next_monday,
+        )
+
+
+def test_half_open_interval_with_observance():
+    # Prompted by GH 49075
+    # Check for holidays that have a half-open date interval where
+    # they have either a start_date or end_date defined along
+    # with a defined observance pattern to make sure that the return type
+    # for Holiday.dates() remains consistent before & after the year that
+    # marks the 'edge' of the half-open date interval.
+
+    holiday_1 = Holiday(
+        "Arbitrary Holiday - start 2022-03-14",
+        start_date=datetime(2022, 3, 14),
+        month=3,
+        day=14,
+        observance=next_monday,
+    )
+    holiday_2 = Holiday(
+        "Arbitrary Holiday 2 - end 2022-03-20",
+        end_date=datetime(2022, 3, 20),
+        month=3,
+        day=20,
+        observance=next_monday,
+    )
+
+    class TestHolidayCalendar(AbstractHolidayCalendar):
+        rules = [
+            USMartinLutherKingJr,
+            holiday_1,
+            holiday_2,
+            USLaborDay,
+        ]
+
+    start = Timestamp("2022-08-01")
+    end = Timestamp("2022-08-31")
+    year_offset = DateOffset(years=5)
+    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+    test_cal = TestHolidayCalendar()
+
+    date_interval_low = test_cal.holidays(start - year_offset, end - year_offset)
+    date_window_edge = test_cal.holidays(start, end)
+    date_interval_high = test_cal.holidays(start + year_offset, end + year_offset)
+
+    tm.assert_index_equal(date_interval_low, expected_results)
+    tm.assert_index_equal(date_window_edge, expected_results)
+    tm.assert_index_equal(date_interval_high, expected_results)
+
+
+def test_holidays_with_timezone_specified_but_no_occurences():
+    # GH 54580
+    # _apply_rule() in holiday.py was silently dropping timezones if you passed it
+    # an empty list of holiday dates that had timezone information
+    start_date = Timestamp("2018-01-01", tz="America/Chicago")
+    end_date = Timestamp("2018-01-11", tz="America/Chicago")
+    test_case = USFederalHolidayCalendar().holidays(
+        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)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/common.py

@@ -0,0 +1,37 @@
+"""
+Assertion helpers and base class for offsets tests
+"""
+from __future__ import annotations
+
+
+def assert_offset_equal(offset, base, expected):
+    actual = offset + base
+    actual_swapped = base + offset
+    actual_apply = offset._apply(base)
+    try:
+        assert actual == expected
+        assert actual_swapped == expected
+        assert actual_apply == expected
+    except AssertionError as err:
+        raise AssertionError(
+            f"\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
+            f"\nAt Date: {base}"
+        ) from err
+
+
+def assert_is_on_offset(offset, date, expected):
+    actual = offset.is_on_offset(date)
+    assert actual == expected, (
+        f"\nExpected: {expected}\nActual: {actual}\nFor Offset: {offset})"
+        f"\nAt Date: {date}"
+    )
+
+
+class WeekDay:
+    MON = 0
+    TUE = 1
+    WED = 2
+    THU = 3
+    FRI = 4
+    SAT = 5
+    SUN = 6

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_day.py

@@ -0,0 +1,236 @@
+"""
+Tests for offsets.BDay
+"""
+from __future__ import annotations
+
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import (
+    ApplyTypeError,
+    BDay,
+    BMonthEnd,
+)
+
+from pandas import (
+    DatetimeIndex,
+    Timedelta,
+    _testing as tm,
+)
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries import offsets
+
+
+@pytest.fixture
+def dt():
+    return datetime(2008, 1, 1)
+
+
+@pytest.fixture
+def _offset():
+    return BDay
+
+
+@pytest.fixture
+def offset(_offset):
+    return _offset()
+
+
+@pytest.fixture
+def offset2(_offset):
+    return _offset(2)
+
+
+class TestBusinessDay:
+    def test_different_normalize_equals(self, _offset, offset2):
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
+        offset = _offset()
+        offset2 = _offset(normalize=True)
+        assert offset != offset2
+
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<BusinessDay>"
+        assert repr(offset2) == "<2 * BusinessDays>"
+
+        expected = "<BusinessDay: offset=datetime.timedelta(days=1)>"
+        assert repr(offset + timedelta(1)) == expected
+
+    def test_with_offset(self, dt, offset):
+        offset = offset + timedelta(hours=2)
+
+        assert (dt + offset) == datetime(2008, 1, 2, 2)
+
+    @pytest.mark.parametrize(
+        "td",
+        [
+            Timedelta(hours=2),
+            Timedelta(hours=2).to_pytimedelta(),
+            Timedelta(hours=2).to_timedelta64(),
+        ],
+        ids=lambda x: type(x),
+    )
+    def test_with_offset_index(self, td, dt, offset):
+        dti = DatetimeIndex([dt])
+        expected = DatetimeIndex([datetime(2008, 1, 2, 2)])
+
+        result = dti + (td + offset)
+        tm.assert_index_equal(result, expected)
+
+        result = dti + (offset + td)
+        tm.assert_index_equal(result, expected)
+
+    def test_eq(self, offset2):
+        assert offset2 == offset2
+
+    def test_hash(self, offset2):
+        assert hash(offset2) == hash(offset2)
+
+    def test_add_datetime(self, dt, offset2):
+        assert offset2 + dt == datetime(2008, 1, 3)
+        assert offset2 + np.datetime64("2008-01-01 00:00:00") == datetime(2008, 1, 3)
+
+    def testRollback1(self, dt, _offset):
+        assert _offset(10).rollback(dt) == dt
+
+    def testRollback2(self, _offset):
+        assert _offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4)
+
+    def testRollforward1(self, dt, _offset):
+        assert _offset(10).rollforward(dt) == dt
+
+    def testRollforward2(self, _offset):
+        assert _offset(10).rollforward(datetime(2008, 1, 5)) == datetime(2008, 1, 7)
+
+    def test_roll_date_object(self, offset):
+        dt = date(2012, 9, 15)
+
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 9, 14)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 9, 17)
+
+        offset = offsets.Day()
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 9, 15)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 9, 15)
+
+    @pytest.mark.parametrize(
+        "dt, expected",
+        [
+            (datetime(2008, 1, 1), True),
+            (datetime(2008, 1, 5), False),
+        ],
+    )
+    def test_is_on_offset(self, offset, dt, expected):
+        assert_is_on_offset(offset, dt, expected)
+
+    apply_cases: list[tuple[int, dict[datetime, datetime]]] = [
+        (
+            1,
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 2),
+                datetime(2008, 1, 4): datetime(2008, 1, 7),
+                datetime(2008, 1, 5): datetime(2008, 1, 7),
+                datetime(2008, 1, 6): datetime(2008, 1, 7),
+                datetime(2008, 1, 7): datetime(2008, 1, 8),
+            },
+        ),
+        (
+            2,
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 3),
+                datetime(2008, 1, 4): datetime(2008, 1, 8),
+                datetime(2008, 1, 5): datetime(2008, 1, 8),
+                datetime(2008, 1, 6): datetime(2008, 1, 8),
+                datetime(2008, 1, 7): datetime(2008, 1, 9),
+            },
+        ),
+        (
+            -1,
+            {
+                datetime(2008, 1, 1): datetime(2007, 12, 31),
+                datetime(2008, 1, 4): datetime(2008, 1, 3),
+                datetime(2008, 1, 5): datetime(2008, 1, 4),
+                datetime(2008, 1, 6): datetime(2008, 1, 4),
+                datetime(2008, 1, 7): datetime(2008, 1, 4),
+                datetime(2008, 1, 8): datetime(2008, 1, 7),
+            },
+        ),
+        (
+            -2,
+            {
+                datetime(2008, 1, 1): datetime(2007, 12, 28),
+                datetime(2008, 1, 4): datetime(2008, 1, 2),
+                datetime(2008, 1, 5): datetime(2008, 1, 3),
+                datetime(2008, 1, 6): datetime(2008, 1, 3),
+                datetime(2008, 1, 7): datetime(2008, 1, 3),
+                datetime(2008, 1, 8): datetime(2008, 1, 4),
+                datetime(2008, 1, 9): datetime(2008, 1, 7),
+            },
+        ),
+        (
+            0,
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 4): datetime(2008, 1, 4),
+                datetime(2008, 1, 5): datetime(2008, 1, 7),
+                datetime(2008, 1, 6): datetime(2008, 1, 7),
+                datetime(2008, 1, 7): datetime(2008, 1, 7),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", apply_cases)
+    def test_apply(self, case, _offset):
+        n, cases = case
+        offset = _offset(n)
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_apply_large_n(self, _offset):
+        dt = datetime(2012, 10, 23)
+
+        result = dt + _offset(10)
+        assert result == datetime(2012, 11, 6)
+
+        result = dt + _offset(100) - _offset(100)
+        assert result == dt
+
+        off = _offset() * 6
+        rs = datetime(2012, 1, 1) - off
+        xp = datetime(2011, 12, 23)
+        assert rs == xp
+
+        st = datetime(2011, 12, 18)
+        rs = st + off
+        xp = datetime(2011, 12, 26)
+        assert rs == xp
+
+        off = _offset() * 10
+        rs = datetime(2014, 1, 5) + off  # see #5890
+        xp = datetime(2014, 1, 17)
+        assert rs == xp
+
+    def test_apply_corner(self, _offset):
+        if _offset is BDay:
+            msg = "Only know how to combine business day with datetime or timedelta"
+        else:
+            msg = (
+                "Only know how to combine trading day "
+                "with datetime, datetime64 or timedelta"
+            )
+        with pytest.raises(ApplyTypeError, match=msg):
+            _offset()._apply(BMonthEnd())

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_hour.py

@@ -0,0 +1,1445 @@
+"""
+Tests for offsets.BusinessHour
+"""
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    time as dt_time,
+)
+
+import pytest
+
+from pandas._libs.tslibs import (
+    Timedelta,
+    Timestamp,
+)
+from pandas._libs.tslibs.offsets import (
+    BDay,
+    BusinessHour,
+    Nano,
+)
+
+from pandas import (
+    DatetimeIndex,
+    _testing as tm,
+    date_range,
+)
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+
+@pytest.fixture
+def dt():
+    return datetime(2014, 7, 1, 10, 00)
+
+
+@pytest.fixture
+def _offset():
+    return BusinessHour
+
+
+@pytest.fixture
+def offset1():
+    return BusinessHour()
+
+
+@pytest.fixture
+def offset2():
+    return BusinessHour(n=3)
+
+
+@pytest.fixture
+def offset3():
+    return BusinessHour(n=-1)
+
+
+@pytest.fixture
+def offset4():
+    return BusinessHour(n=-4)
+
+
+@pytest.fixture
+def offset5():
+    return BusinessHour(start=dt_time(11, 0), end=dt_time(14, 30))
+
+
+@pytest.fixture
+def offset6():
+    return BusinessHour(start="20:00", end="05:00")
+
+
+@pytest.fixture
+def offset7():
+    return BusinessHour(n=-2, start=dt_time(21, 30), end=dt_time(6, 30))
+
+
+@pytest.fixture
+def offset8():
+    return BusinessHour(start=["09:00", "13:00"], end=["12:00", "17:00"])
+
+
+@pytest.fixture
+def offset9():
+    return BusinessHour(n=3, start=["09:00", "22:00"], end=["13:00", "03:00"])
+
+
+@pytest.fixture
+def offset10():
+    return BusinessHour(n=-1, start=["23:00", "13:00"], end=["02:00", "17:00"])
+
+
+class TestBusinessHour:
+    @pytest.mark.parametrize(
+        "start,end,match",
+        [
+            (
+                dt_time(11, 0, 5),
+                "17:00",
+                "time data must be specified only with hour and minute",
+            ),
+            ("AAA", "17:00", "time data must match '%H:%M' format"),
+            ("14:00:05", "17:00", "time data must match '%H:%M' format"),
+            ([], "17:00", "Must include at least 1 start time"),
+            ("09:00", [], "Must include at least 1 end time"),
+            (
+                ["09:00", "11:00"],
+                "17:00",
+                "number of starting time and ending time must be the same",
+            ),
+            (
+                ["09:00", "11:00"],
+                ["10:00"],
+                "number of starting time and ending time must be the same",
+            ),
+            (
+                ["09:00", "11:00"],
+                ["12:00", "20:00"],
+                r"invalid starting and ending time\(s\): opening hours should not "
+                "touch or overlap with one another",
+            ),
+            (
+                ["12:00", "20:00"],
+                ["09:00", "11:00"],
+                r"invalid starting and ending time\(s\): opening hours should not "
+                "touch or overlap with one another",
+            ),
+        ],
+    )
+    def test_constructor_errors(self, start, end, match):
+        with pytest.raises(ValueError, match=match):
+            BusinessHour(start=start, end=end)
+
+    def test_different_normalize_equals(self, _offset):
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
+        offset = _offset()
+        offset2 = _offset(normalize=True)
+        assert offset != offset2
+
+    def test_repr(
+        self,
+        offset1,
+        offset2,
+        offset3,
+        offset4,
+        offset5,
+        offset6,
+        offset7,
+        offset8,
+        offset9,
+        offset10,
+    ):
+        assert repr(offset1) == "<BusinessHour: bh=09:00-17:00>"
+        assert repr(offset2) == "<3 * BusinessHours: bh=09:00-17:00>"
+        assert repr(offset3) == "<-1 * BusinessHour: bh=09:00-17:00>"
+        assert repr(offset4) == "<-4 * BusinessHours: bh=09:00-17:00>"
+
+        assert repr(offset5) == "<BusinessHour: bh=11:00-14:30>"
+        assert repr(offset6) == "<BusinessHour: bh=20:00-05:00>"
+        assert repr(offset7) == "<-2 * BusinessHours: bh=21:30-06:30>"
+        assert repr(offset8) == "<BusinessHour: bh=09:00-12:00,13:00-17:00>"
+        assert repr(offset9) == "<3 * BusinessHours: bh=09:00-13:00,22:00-03:00>"
+        assert repr(offset10) == "<-1 * BusinessHour: bh=13:00-17:00,23:00-02:00>"
+
+    def test_with_offset(self, dt):
+        expected = Timestamp("2014-07-01 13:00")
+
+        assert dt + BusinessHour() * 3 == expected
+        assert dt + BusinessHour(n=3) == expected
+
+    @pytest.mark.parametrize(
+        "offset_name",
+        ["offset1", "offset2", "offset3", "offset4", "offset8", "offset9", "offset10"],
+    )
+    def test_eq_attribute(self, offset_name, request):
+        offset = request.getfixturevalue(offset_name)
+        assert offset == offset
+
+    @pytest.mark.parametrize(
+        "offset1,offset2",
+        [
+            (BusinessHour(start="09:00"), BusinessHour()),
+            (
+                BusinessHour(start=["23:00", "13:00"], end=["12:00", "17:00"]),
+                BusinessHour(start=["13:00", "23:00"], end=["17:00", "12:00"]),
+            ),
+        ],
+    )
+    def test_eq(self, offset1, offset2):
+        assert offset1 == offset2
+
+    @pytest.mark.parametrize(
+        "offset1,offset2",
+        [
+            (BusinessHour(), BusinessHour(-1)),
+            (BusinessHour(start="09:00"), BusinessHour(start="09:01")),
+            (
+                BusinessHour(start="09:00", end="17:00"),
+                BusinessHour(start="17:00", end="09:01"),
+            ),
+            (
+                BusinessHour(start=["13:00", "23:00"], end=["18:00", "07:00"]),
+                BusinessHour(start=["13:00", "23:00"], end=["17:00", "12:00"]),
+            ),
+        ],
+    )
+    def test_neq(self, offset1, offset2):
+        assert offset1 != offset2
+
+    @pytest.mark.parametrize(
+        "offset_name",
+        ["offset1", "offset2", "offset3", "offset4", "offset8", "offset9", "offset10"],
+    )
+    def test_hash(self, offset_name, request):
+        offset = request.getfixturevalue(offset_name)
+        assert offset == offset
+
+    def test_add_datetime(
+        self,
+        dt,
+        offset1,
+        offset2,
+        offset3,
+        offset4,
+        offset8,
+        offset9,
+        offset10,
+    ):
+        assert offset1 + dt == datetime(2014, 7, 1, 11)
+        assert offset2 + dt == datetime(2014, 7, 1, 13)
+        assert offset3 + dt == datetime(2014, 6, 30, 17)
+        assert offset4 + dt == datetime(2014, 6, 30, 14)
+        assert offset8 + dt == datetime(2014, 7, 1, 11)
+        assert offset9 + dt == datetime(2014, 7, 1, 22)
+        assert offset10 + dt == datetime(2014, 7, 1, 1)
+
+    def test_sub(self, dt, offset2, _offset):
+        off = offset2
+        msg = "Cannot subtract datetime from offset"
+        with pytest.raises(TypeError, match=msg):
+            off - dt
+        assert 2 * off - off == off
+
+        assert dt - offset2 == dt + _offset(-3)
+
+    def test_multiply_by_zero(self, dt, offset1, offset2):
+        assert dt - 0 * offset1 == dt
+        assert dt + 0 * offset1 == dt
+        assert dt - 0 * offset2 == dt
+        assert dt + 0 * offset2 == dt
+
+    def testRollback1(
+        self,
+        dt,
+        _offset,
+        offset1,
+        offset2,
+        offset3,
+        offset4,
+        offset5,
+        offset6,
+        offset7,
+        offset8,
+        offset9,
+        offset10,
+    ):
+        assert offset1.rollback(dt) == dt
+        assert offset2.rollback(dt) == dt
+        assert offset3.rollback(dt) == dt
+        assert offset4.rollback(dt) == dt
+        assert offset5.rollback(dt) == datetime(2014, 6, 30, 14, 30)
+        assert offset6.rollback(dt) == datetime(2014, 7, 1, 5, 0)
+        assert offset7.rollback(dt) == datetime(2014, 7, 1, 6, 30)
+        assert offset8.rollback(dt) == dt
+        assert offset9.rollback(dt) == dt
+        assert offset10.rollback(dt) == datetime(2014, 7, 1, 2)
+
+        datet = datetime(2014, 7, 1, 0)
+        assert offset1.rollback(datet) == datetime(2014, 6, 30, 17)
+        assert offset2.rollback(datet) == datetime(2014, 6, 30, 17)
+        assert offset3.rollback(datet) == datetime(2014, 6, 30, 17)
+        assert offset4.rollback(datet) == datetime(2014, 6, 30, 17)
+        assert offset5.rollback(datet) == datetime(2014, 6, 30, 14, 30)
+        assert offset6.rollback(datet) == datet
+        assert offset7.rollback(datet) == datet
+        assert offset8.rollback(datet) == datetime(2014, 6, 30, 17)
+        assert offset9.rollback(datet) == datet
+        assert offset10.rollback(datet) == datet
+
+        assert _offset(5).rollback(dt) == dt
+
+    def testRollback2(self, _offset):
+        assert _offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime(
+            2014, 7, 4, 17, 0
+        )
+
+    def testRollforward1(
+        self,
+        dt,
+        _offset,
+        offset1,
+        offset2,
+        offset3,
+        offset4,
+        offset5,
+        offset6,
+        offset7,
+        offset8,
+        offset9,
+        offset10,
+    ):
+        assert offset1.rollforward(dt) == dt
+        assert offset2.rollforward(dt) == dt
+        assert offset3.rollforward(dt) == dt
+        assert offset4.rollforward(dt) == dt
+        assert offset5.rollforward(dt) == datetime(2014, 7, 1, 11, 0)
+        assert offset6.rollforward(dt) == datetime(2014, 7, 1, 20, 0)
+        assert offset7.rollforward(dt) == datetime(2014, 7, 1, 21, 30)
+        assert offset8.rollforward(dt) == dt
+        assert offset9.rollforward(dt) == dt
+        assert offset10.rollforward(dt) == datetime(2014, 7, 1, 13)
+
+        datet = datetime(2014, 7, 1, 0)
+        assert offset1.rollforward(datet) == datetime(2014, 7, 1, 9)
+        assert offset2.rollforward(datet) == datetime(2014, 7, 1, 9)
+        assert offset3.rollforward(datet) == datetime(2014, 7, 1, 9)
+        assert offset4.rollforward(datet) == datetime(2014, 7, 1, 9)
+        assert offset5.rollforward(datet) == datetime(2014, 7, 1, 11)
+        assert offset6.rollforward(datet) == datet
+        assert offset7.rollforward(datet) == datet
+        assert offset8.rollforward(datet) == datetime(2014, 7, 1, 9)
+        assert offset9.rollforward(datet) == datet
+        assert offset10.rollforward(datet) == datet
+
+        assert _offset(5).rollforward(dt) == dt
+
+    def testRollforward2(self, _offset):
+        assert _offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime(
+            2014, 7, 7, 9
+        )
+
+    def test_roll_date_object(self):
+        offset = BusinessHour()
+
+        dt = datetime(2014, 7, 6, 15, 0)
+
+        result = offset.rollback(dt)
+        assert result == datetime(2014, 7, 4, 17)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2014, 7, 7, 9)
+
+    normalize_cases = []
+    normalize_cases.append(
+        (
+            BusinessHour(normalize=True),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 2),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 2),
+                datetime(2014, 7, 1, 0): datetime(2014, 7, 1),
+                datetime(2014, 7, 4, 15): datetime(2014, 7, 4),
+                datetime(2014, 7, 4, 15, 59): datetime(2014, 7, 4),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7),
+                datetime(2014, 7, 5, 23): datetime(2014, 7, 7),
+                datetime(2014, 7, 6, 10): datetime(2014, 7, 7),
+            },
+        )
+    )
+
+    normalize_cases.append(
+        (
+            BusinessHour(-1, normalize=True),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 6, 30),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 10): datetime(2014, 6, 30),
+                datetime(2014, 7, 1, 0): datetime(2014, 6, 30),
+                datetime(2014, 7, 7, 10): datetime(2014, 7, 4),
+                datetime(2014, 7, 7, 10, 1): datetime(2014, 7, 7),
+                datetime(2014, 7, 5, 23): datetime(2014, 7, 4),
+                datetime(2014, 7, 6, 10): datetime(2014, 7, 4),
+            },
+        )
+    )
+
+    normalize_cases.append(
+        (
+            BusinessHour(1, normalize=True, start="17:00", end="04:00"),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 2),
+                datetime(2014, 7, 2, 2): datetime(2014, 7, 2),
+                datetime(2014, 7, 2, 3): datetime(2014, 7, 2),
+                datetime(2014, 7, 4, 23): datetime(2014, 7, 5),
+                datetime(2014, 7, 5, 2): datetime(2014, 7, 5),
+                datetime(2014, 7, 7, 2): datetime(2014, 7, 7),
+                datetime(2014, 7, 7, 17): datetime(2014, 7, 7),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", normalize_cases)
+    def test_normalize(self, case):
+        offset, cases = case
+        for dt, expected in cases.items():
+            assert offset._apply(dt) == expected
+
+    on_offset_cases = []
+    on_offset_cases.append(
+        (
+            BusinessHour(),
+            {
+                datetime(2014, 7, 1, 9): True,
+                datetime(2014, 7, 1, 8, 59): False,
+                datetime(2014, 7, 1, 8): False,
+                datetime(2014, 7, 1, 17): True,
+                datetime(2014, 7, 1, 17, 1): False,
+                datetime(2014, 7, 1, 18): False,
+                datetime(2014, 7, 5, 9): False,
+                datetime(2014, 7, 6, 12): False,
+            },
+        )
+    )
+
+    on_offset_cases.append(
+        (
+            BusinessHour(start="10:00", end="15:00"),
+            {
+                datetime(2014, 7, 1, 9): False,
+                datetime(2014, 7, 1, 10): True,
+                datetime(2014, 7, 1, 15): True,
+                datetime(2014, 7, 1, 15, 1): False,
+                datetime(2014, 7, 5, 12): False,
+                datetime(2014, 7, 6, 12): False,
+            },
+        )
+    )
+
+    on_offset_cases.append(
+        (
+            BusinessHour(start="19:00", end="05:00"),
+            {
+                datetime(2014, 7, 1, 9, 0): False,
+                datetime(2014, 7, 1, 10, 0): False,
+                datetime(2014, 7, 1, 15): False,
+                datetime(2014, 7, 1, 15, 1): False,
+                datetime(2014, 7, 5, 12, 0): False,
+                datetime(2014, 7, 6, 12, 0): False,
+                datetime(2014, 7, 1, 19, 0): True,
+                datetime(2014, 7, 2, 0, 0): True,
+                datetime(2014, 7, 4, 23): True,
+                datetime(2014, 7, 5, 1): True,
+                datetime(2014, 7, 5, 5, 0): True,
+                datetime(2014, 7, 6, 23, 0): False,
+                datetime(2014, 7, 7, 3, 0): False,
+            },
+        )
+    )
+
+    on_offset_cases.append(
+        (
+            BusinessHour(start=["09:00", "13:00"], end=["12:00", "17:00"]),
+            {
+                datetime(2014, 7, 1, 9): True,
+                datetime(2014, 7, 1, 8, 59): False,
+                datetime(2014, 7, 1, 8): False,
+                datetime(2014, 7, 1, 17): True,
+                datetime(2014, 7, 1, 17, 1): False,
+                datetime(2014, 7, 1, 18): False,
+                datetime(2014, 7, 5, 9): False,
+                datetime(2014, 7, 6, 12): False,
+                datetime(2014, 7, 1, 12, 30): False,
+            },
+        )
+    )
+
+    on_offset_cases.append(
+        (
+            BusinessHour(start=["19:00", "23:00"], end=["21:00", "05:00"]),
+            {
+                datetime(2014, 7, 1, 9, 0): False,
+                datetime(2014, 7, 1, 10, 0): False,
+                datetime(2014, 7, 1, 15): False,
+                datetime(2014, 7, 1, 15, 1): False,
+                datetime(2014, 7, 5, 12, 0): False,
+                datetime(2014, 7, 6, 12, 0): False,
+                datetime(2014, 7, 1, 19, 0): True,
+                datetime(2014, 7, 2, 0, 0): True,
+                datetime(2014, 7, 4, 23): True,
+                datetime(2014, 7, 5, 1): True,
+                datetime(2014, 7, 5, 5, 0): True,
+                datetime(2014, 7, 6, 23, 0): False,
+                datetime(2014, 7, 7, 3, 0): False,
+                datetime(2014, 7, 4, 22): False,
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, cases = case
+        for dt, expected in cases.items():
+            assert offset.is_on_offset(dt) == expected
+
+    apply_cases = [
+        (
+            BusinessHour(),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 12),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 1, 19): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 2, 9),
+                datetime(2014, 7, 1, 16, 30, 15): datetime(2014, 7, 2, 9, 30, 15),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 2, 12),
+                # out of business hours
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 10),
+                # saturday
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 10),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 10),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7, 9, 30),
+                datetime(2014, 7, 4, 16, 30, 30): datetime(2014, 7, 7, 9, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(4),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 2, 9),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 2, 11),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 2, 12),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 13),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 13),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7, 12, 30),
+                datetime(2014, 7, 4, 16, 30, 30): datetime(2014, 7, 7, 12, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(-1),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 10),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 1, 12),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 1, 10): datetime(2014, 6, 30, 17),
+                datetime(2014, 7, 1, 16, 30, 15): datetime(2014, 7, 1, 15, 30, 15),
+                datetime(2014, 7, 1, 9, 30, 15): datetime(2014, 6, 30, 16, 30, 15),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 1, 5): datetime(2014, 6, 30, 16),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 2, 10),
+                # out of business hours
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 16),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 2, 16),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 16),
+                # saturday
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 4, 16),
+                datetime(2014, 7, 7, 9): datetime(2014, 7, 4, 16),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 4, 16, 30),
+                datetime(2014, 7, 7, 9, 30, 30): datetime(2014, 7, 4, 16, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(-4),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 6, 30, 15),
+                datetime(2014, 7, 1, 13): datetime(2014, 6, 30, 17),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 1, 11),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1, 12),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 13),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 1, 13),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 4, 13),
+                datetime(2014, 7, 4, 18): datetime(2014, 7, 4, 13),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 4, 13, 30),
+                datetime(2014, 7, 7, 9, 30, 30): datetime(2014, 7, 4, 13, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(start="13:00", end="16:00"),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 1, 19): datetime(2014, 7, 2, 14),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 2, 14),
+                datetime(2014, 7, 1, 15, 30, 15): datetime(2014, 7, 2, 13, 30, 15),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 14),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 14),
+            },
+        ),
+        (
+            BusinessHour(n=2, start="13:00", end="16:00"),
+            {
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 15),
+                datetime(2014, 7, 2, 14, 30): datetime(2014, 7, 3, 13, 30),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 15),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 15),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 15),
+                datetime(2014, 7, 4, 14, 30): datetime(2014, 7, 7, 13, 30),
+                datetime(2014, 7, 4, 14, 30, 30): datetime(2014, 7, 7, 13, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=-1, start="13:00", end="16:00"),
+            {
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 2, 13): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 2, 15): datetime(2014, 7, 2, 14),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 16): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 13, 30, 15): datetime(2014, 7, 1, 15, 30, 15),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 4, 15),
+                datetime(2014, 7, 7, 11): datetime(2014, 7, 4, 15),
+            },
+        ),
+        (
+            BusinessHour(n=-3, start="10:00", end="16:00"),
+            {
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 13),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 2, 11),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 1, 13),
+                datetime(2014, 7, 2, 13): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 2, 11, 30): datetime(2014, 7, 1, 14, 30),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 13),
+                datetime(2014, 7, 4, 10): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 4, 13),
+                datetime(2014, 7, 4, 16): datetime(2014, 7, 4, 13),
+                datetime(2014, 7, 4, 12, 30): datetime(2014, 7, 3, 15, 30),
+                datetime(2014, 7, 4, 12, 30, 30): datetime(2014, 7, 3, 15, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(start="19:00", end="05:00"),
+            {
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 20),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 2, 20),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 20),
+                datetime(2014, 7, 2, 13): datetime(2014, 7, 2, 20),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 20),
+                datetime(2014, 7, 2, 4, 30): datetime(2014, 7, 2, 19, 30),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 1),
+                datetime(2014, 7, 4, 10): datetime(2014, 7, 4, 20),
+                datetime(2014, 7, 4, 23): datetime(2014, 7, 5, 0),
+                datetime(2014, 7, 5, 0): datetime(2014, 7, 5, 1),
+                datetime(2014, 7, 5, 4): datetime(2014, 7, 7, 19),
+                datetime(2014, 7, 5, 4, 30): datetime(2014, 7, 7, 19, 30),
+                datetime(2014, 7, 5, 4, 30, 30): datetime(2014, 7, 7, 19, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=-1, start="19:00", end="05:00"),
+            {
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 4),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 13): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 20): datetime(2014, 7, 2, 5),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 19, 30): datetime(2014, 7, 2, 4, 30),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 23),
+                datetime(2014, 7, 3, 6): datetime(2014, 7, 3, 4),
+                datetime(2014, 7, 4, 23): datetime(2014, 7, 4, 22),
+                datetime(2014, 7, 5, 0): datetime(2014, 7, 4, 23),
+                datetime(2014, 7, 5, 4): datetime(2014, 7, 5, 3),
+                datetime(2014, 7, 7, 19, 30): datetime(2014, 7, 5, 4, 30),
+                datetime(2014, 7, 7, 19, 30, 30): datetime(2014, 7, 5, 4, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=4, start="00:00", end="23:00"),
+            {
+                datetime(2014, 7, 3, 22): datetime(2014, 7, 4, 3),
+                datetime(2014, 7, 4, 22): datetime(2014, 7, 7, 3),
+                datetime(2014, 7, 3, 22, 30): datetime(2014, 7, 4, 3, 30),
+                datetime(2014, 7, 3, 22, 20): datetime(2014, 7, 4, 3, 20),
+                datetime(2014, 7, 4, 22, 30, 30): datetime(2014, 7, 7, 3, 30, 30),
+                datetime(2014, 7, 4, 22, 30, 20): datetime(2014, 7, 7, 3, 30, 20),
+            },
+        ),
+        (
+            BusinessHour(n=-4, start="00:00", end="23:00"),
+            {
+                datetime(2014, 7, 4, 3): datetime(2014, 7, 3, 22),
+                datetime(2014, 7, 7, 3): datetime(2014, 7, 4, 22),
+                datetime(2014, 7, 4, 3, 30): datetime(2014, 7, 3, 22, 30),
+                datetime(2014, 7, 4, 3, 20): datetime(2014, 7, 3, 22, 20),
+                datetime(2014, 7, 7, 3, 30, 30): datetime(2014, 7, 4, 22, 30, 30),
+                datetime(2014, 7, 7, 3, 30, 20): datetime(2014, 7, 4, 22, 30, 20),
+            },
+        ),
+        (
+            BusinessHour(start=["09:00", "14:00"], end=["12:00", "18:00"]),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 1, 19): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1, 17),
+                datetime(2014, 7, 1, 16, 30, 15): datetime(2014, 7, 1, 17, 30, 15),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2, 9),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 2, 14),
+                # out of business hours
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 10),
+                # saturday
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 10),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 9),
+                datetime(2014, 7, 4, 17, 30): datetime(2014, 7, 7, 9, 30),
+                datetime(2014, 7, 4, 17, 30, 30): datetime(2014, 7, 7, 9, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=4, start=["09:00", "14:00"], end=["12:00", "18:00"]),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 17),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 2, 9),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 2, 10),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 2, 11),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 2, 14),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 2, 17),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 15),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 15),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 15),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 15),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 15),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 14),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7, 11, 30),
+                datetime(2014, 7, 4, 16, 30, 30): datetime(2014, 7, 7, 11, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=-4, start=["09:00", "14:00"], end=["12:00", "18:00"]),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 6, 30, 16),
+                datetime(2014, 7, 1, 13): datetime(2014, 6, 30, 17),
+                datetime(2014, 7, 1, 15): datetime(2014, 6, 30, 18),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1, 10),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 11),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 1, 12),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 12),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 2, 12),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 12),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 4, 12),
+                datetime(2014, 7, 4, 18): datetime(2014, 7, 4, 12),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 4, 14, 30),
+                datetime(2014, 7, 7, 9, 30, 30): datetime(2014, 7, 4, 14, 30, 30),
+            },
+        ),
+        (
+            BusinessHour(n=-1, start=["19:00", "03:00"], end=["01:00", "05:00"]),
+            {
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1, 4),
+                datetime(2014, 7, 2, 14): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 13): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 20): datetime(2014, 7, 2, 5),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 2, 4),
+                datetime(2014, 7, 2, 4): datetime(2014, 7, 2, 1),
+                datetime(2014, 7, 2, 19, 30): datetime(2014, 7, 2, 4, 30),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 2, 23),
+                datetime(2014, 7, 3, 6): datetime(2014, 7, 3, 4),
+                datetime(2014, 7, 4, 23): datetime(2014, 7, 4, 22),
+                datetime(2014, 7, 5, 0): datetime(2014, 7, 4, 23),
+                datetime(2014, 7, 5, 4): datetime(2014, 7, 5, 0),
+                datetime(2014, 7, 7, 3, 30): datetime(2014, 7, 5, 0, 30),
+                datetime(2014, 7, 7, 19, 30): datetime(2014, 7, 7, 4, 30),
+                datetime(2014, 7, 7, 19, 30, 30): datetime(2014, 7, 7, 4, 30, 30),
+            },
+        ),
+    ]
+
+    # long business hours (see gh-26381)
+
+    # multiple business hours
+
+    @pytest.mark.parametrize("case", apply_cases)
+    def test_apply(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    apply_large_n_cases = [
+        (
+            # A week later
+            BusinessHour(40),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 8, 11),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 8, 13),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 8, 15),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 8, 16),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 9, 9),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 9, 11),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 9, 9),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 10, 9),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 10, 9),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 10, 9),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 14, 9),
+                datetime(2014, 7, 4, 18): datetime(2014, 7, 14, 9),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 14, 9, 30),
+                datetime(2014, 7, 7, 9, 30, 30): datetime(2014, 7, 14, 9, 30, 30),
+            },
+        ),
+        (
+            # 3 days and 1 hour before
+            BusinessHour(-25),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 6, 26, 10),
+                datetime(2014, 7, 1, 13): datetime(2014, 6, 26, 12),
+                datetime(2014, 7, 1, 9): datetime(2014, 6, 25, 16),
+                datetime(2014, 7, 1, 10): datetime(2014, 6, 25, 17),
+                datetime(2014, 7, 3, 11): datetime(2014, 6, 30, 10),
+                datetime(2014, 7, 3, 8): datetime(2014, 6, 27, 16),
+                datetime(2014, 7, 3, 19): datetime(2014, 6, 30, 16),
+                datetime(2014, 7, 3, 23): datetime(2014, 6, 30, 16),
+                datetime(2014, 7, 4, 9): datetime(2014, 6, 30, 16),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 6, 18): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 1, 16, 30),
+                datetime(2014, 7, 7, 10, 30, 30): datetime(2014, 7, 2, 9, 30, 30),
+            },
+        ),
+        (
+            # 5 days and 3 hours later
+            BusinessHour(28, start="21:00", end="02:00"),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 9, 0),
+                datetime(2014, 7, 1, 22): datetime(2014, 7, 9, 1),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 9, 21),
+                datetime(2014, 7, 2, 2): datetime(2014, 7, 10, 0),
+                datetime(2014, 7, 3, 21): datetime(2014, 7, 11, 0),
+                datetime(2014, 7, 4, 1): datetime(2014, 7, 11, 23),
+                datetime(2014, 7, 4, 2): datetime(2014, 7, 12, 0),
+                datetime(2014, 7, 4, 3): datetime(2014, 7, 12, 0),
+                datetime(2014, 7, 5, 1): datetime(2014, 7, 14, 23),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 15, 0),
+                datetime(2014, 7, 6, 18): datetime(2014, 7, 15, 0),
+                datetime(2014, 7, 7, 1): datetime(2014, 7, 15, 0),
+                datetime(2014, 7, 7, 23, 30): datetime(2014, 7, 15, 21, 30),
+            },
+        ),
+        (
+            # large n for multiple opening hours (3 days and 1 hour before)
+            BusinessHour(n=-25, start=["09:00", "14:00"], end=["12:00", "19:00"]),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 6, 26, 10),
+                datetime(2014, 7, 1, 13): datetime(2014, 6, 26, 11),
+                datetime(2014, 7, 1, 9): datetime(2014, 6, 25, 18),
+                datetime(2014, 7, 1, 10): datetime(2014, 6, 25, 19),
+                datetime(2014, 7, 3, 11): datetime(2014, 6, 30, 10),
+                datetime(2014, 7, 3, 8): datetime(2014, 6, 27, 18),
+                datetime(2014, 7, 3, 19): datetime(2014, 6, 30, 18),
+                datetime(2014, 7, 3, 23): datetime(2014, 6, 30, 18),
+                datetime(2014, 7, 4, 9): datetime(2014, 6, 30, 18),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 1, 18),
+                datetime(2014, 7, 6, 18): datetime(2014, 7, 1, 18),
+                datetime(2014, 7, 7, 9, 30): datetime(2014, 7, 1, 18, 30),
+                datetime(2014, 7, 7, 10, 30, 30): datetime(2014, 7, 2, 9, 30, 30),
+            },
+        ),
+        (
+            # 5 days and 3 hours later
+            BusinessHour(28, start=["21:00", "03:00"], end=["01:00", "04:00"]),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 9, 0),
+                datetime(2014, 7, 1, 22): datetime(2014, 7, 9, 3),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 9, 21),
+                datetime(2014, 7, 2, 2): datetime(2014, 7, 9, 23),
+                datetime(2014, 7, 3, 21): datetime(2014, 7, 11, 0),
+                datetime(2014, 7, 4, 1): datetime(2014, 7, 11, 23),
+                datetime(2014, 7, 4, 2): datetime(2014, 7, 11, 23),
+                datetime(2014, 7, 4, 3): datetime(2014, 7, 11, 23),
+                datetime(2014, 7, 4, 21): datetime(2014, 7, 12, 0),
+                datetime(2014, 7, 5, 0): datetime(2014, 7, 14, 22),
+                datetime(2014, 7, 5, 1): datetime(2014, 7, 14, 23),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 14, 23),
+                datetime(2014, 7, 6, 18): datetime(2014, 7, 14, 23),
+                datetime(2014, 7, 7, 1): datetime(2014, 7, 14, 23),
+                datetime(2014, 7, 7, 23, 30): datetime(2014, 7, 15, 21, 30),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", apply_large_n_cases)
+    def test_apply_large_n(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_apply_nanoseconds(self):
+        tests = [
+            (
+                BusinessHour(),
+                {
+                    Timestamp("2014-07-04 15:00")
+                    + Nano(5): Timestamp("2014-07-04 16:00")
+                    + Nano(5),
+                    Timestamp("2014-07-04 16:00")
+                    + Nano(5): Timestamp("2014-07-07 09:00")
+                    + Nano(5),
+                    Timestamp("2014-07-04 16:00")
+                    - Nano(5): Timestamp("2014-07-04 17:00")
+                    - Nano(5),
+                },
+            ),
+            (
+                BusinessHour(-1),
+                {
+                    Timestamp("2014-07-04 15:00")
+                    + Nano(5): Timestamp("2014-07-04 14:00")
+                    + Nano(5),
+                    Timestamp("2014-07-04 10:00")
+                    + Nano(5): Timestamp("2014-07-04 09:00")
+                    + Nano(5),
+                    Timestamp("2014-07-04 10:00")
+                    - Nano(5): Timestamp("2014-07-03 17:00")
+                    - Nano(5),
+                },
+            ),
+        ]
+
+        for offset, cases in tests:
+            for base, expected in cases.items():
+                assert_offset_equal(offset, base, expected)
+
+    @pytest.mark.parametrize("td_unit", ["s", "ms", "us", "ns"])
+    @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+    def test_bday_ignores_timedeltas(self, unit, td_unit):
+        # GH#55608
+        idx = date_range("2010/02/01", "2010/02/10", freq="12h", unit=unit)
+        td = Timedelta(3, unit="h").as_unit(td_unit)
+        off = BDay(offset=td)
+        t1 = idx + off
+
+        exp_unit = tm.get_finest_unit(td.unit, idx.unit)
+
+        expected = DatetimeIndex(
+            [
+                "2010-02-02 03:00:00",
+                "2010-02-02 15:00:00",
+                "2010-02-03 03:00:00",
+                "2010-02-03 15:00:00",
+                "2010-02-04 03:00:00",
+                "2010-02-04 15:00:00",
+                "2010-02-05 03:00:00",
+                "2010-02-05 15:00:00",
+                "2010-02-08 03:00:00",
+                "2010-02-08 15:00:00",
+                "2010-02-08 03:00:00",
+                "2010-02-08 15:00:00",
+                "2010-02-08 03:00:00",
+                "2010-02-08 15:00:00",
+                "2010-02-09 03:00:00",
+                "2010-02-09 15:00:00",
+                "2010-02-10 03:00:00",
+                "2010-02-10 15:00:00",
+                "2010-02-11 03:00:00",
+            ],
+            freq=None,
+        ).as_unit(exp_unit)
+        tm.assert_index_equal(t1, expected)
+
+        # TODO(GH#55564): as_unit will be unnecessary
+        pointwise = DatetimeIndex([x + off for x in idx]).as_unit(exp_unit)
+        tm.assert_index_equal(pointwise, expected)
+
+    def test_add_bday_offset_nanos(self):
+        # GH#55608
+        idx = date_range("2010/02/01", "2010/02/10", freq="12h", unit="ns")
+        off = BDay(offset=Timedelta(3, unit="ns"))
+
+        result = idx + off
+        expected = DatetimeIndex([x + off for x in idx])
+        tm.assert_index_equal(result, expected)
+
+
+class TestOpeningTimes:
+    # opening time should be affected by sign of n, not by n's value and end
+    opening_time_cases = [
+        (
+            [
+                BusinessHour(),
+                BusinessHour(n=2),
+                BusinessHour(n=4),
+                BusinessHour(end="10:00"),
+                BusinessHour(n=2, end="4:00"),
+                BusinessHour(n=4, end="15:00"),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 1, 9),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 1, 9),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 1, 9),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 1, 9),
+                ),
+                # if timestamp is on opening time, next opening time is
+                # as it is
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 2, 10): (
+                    datetime(2014, 7, 3, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                # 2014-07-05 is saturday
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 4, 9),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 4, 9),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 4, 9),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 4, 9),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 4, 9),
+                ),
+                datetime(2014, 7, 7, 9, 1): (
+                    datetime(2014, 7, 8, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(start="11:15"),
+                BusinessHour(n=2, start="11:15"),
+                BusinessHour(n=3, start="11:15"),
+                BusinessHour(start="11:15", end="10:00"),
+                BusinessHour(n=2, start="11:15", end="4:00"),
+                BusinessHour(n=3, start="11:15", end="15:00"),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 1, 11, 15),
+                    datetime(2014, 6, 30, 11, 15),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 11, 15),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 11, 15),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 11, 15),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 11, 15),
+                ),
+                datetime(2014, 7, 2, 10): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 11, 15),
+                ),
+                datetime(2014, 7, 2, 11, 15): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 2, 11, 15),
+                ),
+                datetime(2014, 7, 2, 11, 15, 1): (
+                    datetime(2014, 7, 3, 11, 15),
+                    datetime(2014, 7, 2, 11, 15),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 11, 15),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 4, 11, 15),
+                    datetime(2014, 7, 3, 11, 15),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 11, 15),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 11, 15),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 11, 15),
+                ),
+                datetime(2014, 7, 7, 9, 1): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 11, 15),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(-1),
+                BusinessHour(n=-2),
+                BusinessHour(n=-4),
+                BusinessHour(n=-1, end="10:00"),
+                BusinessHour(n=-2, end="4:00"),
+                BusinessHour(n=-4, end="15:00"),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 1, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 1, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 1, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 1, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 2, 9),
+                ),
+                datetime(2014, 7, 2, 10): (
+                    datetime(2014, 7, 2, 9),
+                    datetime(2014, 7, 3, 9),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 4, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 4, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 4, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 4, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 4, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 7, 9): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 7, 9),
+                ),
+                datetime(2014, 7, 7, 9, 1): (
+                    datetime(2014, 7, 7, 9),
+                    datetime(2014, 7, 8, 9),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(start="17:00", end="05:00"),
+                BusinessHour(n=3, start="17:00", end="03:00"),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 6, 30, 17),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 2, 17),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 2, 17),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 2, 17),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 17),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 4, 17): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 3, 17),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 7, 17, 1): (
+                    datetime(2014, 7, 8, 17),
+                    datetime(2014, 7, 7, 17),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(-1, start="17:00", end="05:00"),
+                BusinessHour(n=-2, start="17:00", end="03:00"),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 6, 30, 17),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 2, 16, 59): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 17),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 3, 17),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 17),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 17),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 17),
+                ),
+                datetime(2014, 7, 7, 18): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 8, 17),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(start=["11:15", "15:00"], end=["13:00", "20:00"]),
+                BusinessHour(n=3, start=["11:15", "15:00"], end=["12:00", "20:00"]),
+                BusinessHour(start=["11:15", "15:00"], end=["13:00", "17:00"]),
+                BusinessHour(n=2, start=["11:15", "15:00"], end=["12:00", "03:00"]),
+                BusinessHour(n=3, start=["11:15", "15:00"], end=["13:00", "16:00"]),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 1, 11, 15),
+                    datetime(2014, 6, 30, 15),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 15),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 15),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 15),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 15),
+                ),
+                datetime(2014, 7, 2, 10): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 1, 15),
+                ),
+                datetime(2014, 7, 2, 11, 15): (
+                    datetime(2014, 7, 2, 11, 15),
+                    datetime(2014, 7, 2, 11, 15),
+                ),
+                datetime(2014, 7, 2, 11, 15, 1): (
+                    datetime(2014, 7, 2, 15),
+                    datetime(2014, 7, 2, 11, 15),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 15),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 4, 11, 15),
+                    datetime(2014, 7, 3, 15),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 15),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 15),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 15),
+                ),
+                datetime(2014, 7, 7, 9, 1): (
+                    datetime(2014, 7, 7, 11, 15),
+                    datetime(2014, 7, 4, 15),
+                ),
+                datetime(2014, 7, 7, 12): (
+                    datetime(2014, 7, 7, 15),
+                    datetime(2014, 7, 7, 11, 15),
+                ),
+            },
+        ),
+        (
+            [
+                BusinessHour(n=-1, start=["17:00", "08:00"], end=["05:00", "10:00"]),
+                BusinessHour(n=-2, start=["08:00", "17:00"], end=["10:00", "03:00"]),
+            ],
+            {
+                datetime(2014, 7, 1, 11): (
+                    datetime(2014, 7, 1, 8),
+                    datetime(2014, 7, 1, 17),
+                ),
+                datetime(2014, 7, 1, 18): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 8),
+                ),
+                datetime(2014, 7, 1, 23): (
+                    datetime(2014, 7, 1, 17),
+                    datetime(2014, 7, 2, 8),
+                ),
+                datetime(2014, 7, 2, 8): (
+                    datetime(2014, 7, 2, 8),
+                    datetime(2014, 7, 2, 8),
+                ),
+                datetime(2014, 7, 2, 9): (
+                    datetime(2014, 7, 2, 8),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 2, 16, 59): (
+                    datetime(2014, 7, 2, 8),
+                    datetime(2014, 7, 2, 17),
+                ),
+                datetime(2014, 7, 5, 10): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 8),
+                ),
+                datetime(2014, 7, 4, 10): (
+                    datetime(2014, 7, 4, 8),
+                    datetime(2014, 7, 4, 17),
+                ),
+                datetime(2014, 7, 4, 23): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 8),
+                ),
+                datetime(2014, 7, 6, 10): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 8),
+                ),
+                datetime(2014, 7, 7, 5): (
+                    datetime(2014, 7, 4, 17),
+                    datetime(2014, 7, 7, 8),
+                ),
+                datetime(2014, 7, 7, 18): (
+                    datetime(2014, 7, 7, 17),
+                    datetime(2014, 7, 8, 8),
+                ),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", opening_time_cases)
+    def test_opening_time(self, case):
+        _offsets, cases = case
+        for offset in _offsets:
+            for dt, (exp_next, exp_prev) in cases.items():
+                assert offset._next_opening_time(dt) == exp_next
+                assert offset._prev_opening_time(dt) == exp_prev

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_month.py

@@ -0,0 +1,217 @@
+"""
+Tests for the following offsets:
+- BMonthBegin
+- BMonthEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+import pandas as pd
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    BMonthBegin,
+    BMonthEnd,
+)
+
+
+@pytest.mark.parametrize("n", [-2, 1])
+@pytest.mark.parametrize(
+    "cls",
+    [
+        BMonthBegin,
+        BMonthEnd,
+    ],
+)
+def test_apply_index(cls, n):
+    offset = cls(n=n)
+    rng = pd.date_range(start="1/1/2000", periods=100000, freq="min")
+    ser = pd.Series(rng)
+
+    res = rng + offset
+    assert res.freq is None  # not retained
+    assert res[0] == rng[0] + offset
+    assert res[-1] == rng[-1] + offset
+    res2 = ser + offset
+    # apply_index is only for indexes, not series, so no res2_v2
+    assert res2.iloc[0] == ser.iloc[0] + offset
+    assert res2.iloc[-1] == ser.iloc[-1] + offset
+
+
+class TestBMonthBegin:
+    def test_offsets_compare_equal(self):
+        # root cause of #456
+        offset1 = BMonthBegin()
+        offset2 = BMonthBegin()
+        assert not offset1 != offset2
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2006, 9, 1): datetime(2006, 10, 2),
+                datetime(2007, 1, 1): datetime(2007, 2, 1),
+                datetime(2006, 12, 1): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2006, 10, 2): datetime(2006, 10, 2),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2006, 9, 15): datetime(2006, 10, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthBegin(2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 3, 3),
+                datetime(2008, 1, 15): datetime(2008, 3, 3),
+                datetime(2006, 12, 29): datetime(2007, 2, 1),
+                datetime(2006, 12, 31): datetime(2007, 2, 1),
+                datetime(2007, 1, 1): datetime(2007, 3, 1),
+                datetime(2006, 11, 1): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 1),
+                datetime(2008, 6, 30): datetime(2008, 6, 2),
+                datetime(2008, 6, 1): datetime(2008, 5, 1),
+                datetime(2008, 3, 10): datetime(2008, 3, 3),
+                datetime(2008, 12, 31): datetime(2008, 12, 1),
+                datetime(2006, 12, 29): datetime(2006, 12, 1),
+                datetime(2006, 12, 30): datetime(2006, 12, 1),
+                datetime(2007, 1, 1): datetime(2006, 12, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (BMonthBegin(), datetime(2007, 12, 31), False),
+        (BMonthBegin(), datetime(2008, 1, 1), True),
+        (BMonthBegin(), datetime(2001, 4, 2), True),
+        (BMonthBegin(), datetime(2008, 3, 3), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+class TestBMonthEnd:
+    def test_normalize(self):
+        dt = datetime(2007, 1, 1, 3)
+
+        result = dt + BMonthEnd(normalize=True)
+        expected = dt.replace(hour=0) + BMonthEnd()
+        assert result == expected
+
+    def test_offsets_compare_equal(self):
+        # root cause of #456
+        offset1 = BMonthEnd()
+        offset2 = BMonthEnd()
+        assert not offset1 != offset2
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2006, 12, 29): datetime(2007, 1, 31),
+                datetime(2006, 12, 31): datetime(2007, 1, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 31),
+                datetime(2006, 12, 1): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2006, 12, 29): datetime(2006, 12, 29),
+                datetime(2006, 12, 31): datetime(2007, 1, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthEnd(2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 1, 31): datetime(2008, 3, 31),
+                datetime(2006, 12, 29): datetime(2007, 2, 28),
+                datetime(2006, 12, 31): datetime(2007, 2, 28),
+                datetime(2007, 1, 1): datetime(2007, 2, 28),
+                datetime(2006, 11, 1): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BMonthEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+                datetime(2008, 6, 30): datetime(2008, 5, 30),
+                datetime(2008, 12, 31): datetime(2008, 11, 28),
+                datetime(2006, 12, 29): datetime(2006, 11, 30),
+                datetime(2006, 12, 30): datetime(2006, 12, 29),
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (BMonthEnd(), datetime(2007, 12, 31), True),
+        (BMonthEnd(), datetime(2008, 1, 1), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_quarter.py

@@ -0,0 +1,315 @@
+"""
+Tests for the following offsets:
+- BQuarterBegin
+- BQuarterEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    BQuarterBegin,
+    BQuarterEnd,
+)
+
+
+def test_quarterly_dont_normalize():
+    date = datetime(2012, 3, 31, 5, 30)
+
+    offsets = (BQuarterEnd, BQuarterBegin)
+
+    for klass in offsets:
+        result = date + klass()
+        assert result.time() == date.time()
+
+
+@pytest.mark.parametrize("offset", [BQuarterBegin(), BQuarterEnd()])
+def test_on_offset(offset):
+    dates = [
+        datetime(2016, m, d)
+        for m in [10, 11, 12]
+        for d in [1, 2, 3, 28, 29, 30, 31]
+        if not (m == 11 and d == 31)
+    ]
+    for date in dates:
+        res = offset.is_on_offset(date)
+        slow_version = date == (date + offset) - offset
+        assert res == slow_version
+
+
+class TestBQuarterBegin:
+    def test_repr(self):
+        expected = "<BusinessQuarterBegin: startingMonth=3>"
+        assert repr(BQuarterBegin()) == expected
+        expected = "<BusinessQuarterBegin: startingMonth=3>"
+        assert repr(BQuarterBegin(startingMonth=3)) == expected
+        expected = "<BusinessQuarterBegin: startingMonth=1>"
+        assert repr(BQuarterBegin(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "BQuarterBegin.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert BQuarterBegin(startingMonth=1).is_anchored()
+            assert BQuarterBegin().is_anchored()
+            assert not BQuarterBegin(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = BQuarterBegin(n=-1, startingMonth=1)
+        assert datetime(2007, 4, 3) + offset == datetime(2007, 4, 2)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BQuarterBegin(startingMonth=1),
+            {
+                datetime(2008, 1, 1): datetime(2008, 4, 1),
+                datetime(2008, 1, 31): datetime(2008, 4, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2008, 3, 31): datetime(2008, 4, 1),
+                datetime(2008, 4, 15): datetime(2008, 7, 1),
+                datetime(2007, 3, 15): datetime(2007, 4, 2),
+                datetime(2007, 2, 28): datetime(2007, 4, 2),
+                datetime(2007, 1, 1): datetime(2007, 4, 2),
+                datetime(2007, 4, 15): datetime(2007, 7, 2),
+                datetime(2007, 7, 1): datetime(2007, 7, 2),
+                datetime(2007, 4, 1): datetime(2007, 4, 2),
+                datetime(2007, 4, 2): datetime(2007, 7, 2),
+                datetime(2008, 4, 30): datetime(2008, 7, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterBegin(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2008, 1, 15): datetime(2008, 2, 1),
+                datetime(2008, 2, 29): datetime(2008, 5, 1),
+                datetime(2008, 3, 15): datetime(2008, 5, 1),
+                datetime(2008, 3, 31): datetime(2008, 5, 1),
+                datetime(2008, 4, 15): datetime(2008, 5, 1),
+                datetime(2008, 8, 15): datetime(2008, 11, 3),
+                datetime(2008, 9, 15): datetime(2008, 11, 3),
+                datetime(2008, 11, 1): datetime(2008, 11, 3),
+                datetime(2008, 4, 30): datetime(2008, 5, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterBegin(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2007, 12, 31): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 1, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 27): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2007, 4, 1): datetime(2007, 4, 2),
+                datetime(2007, 4, 2): datetime(2007, 4, 2),
+                datetime(2007, 7, 1): datetime(2007, 7, 2),
+                datetime(2007, 4, 15): datetime(2007, 7, 2),
+                datetime(2007, 7, 2): datetime(2007, 7, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterBegin(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 1),
+                datetime(2008, 1, 31): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 1, 1),
+                datetime(2008, 2, 29): datetime(2008, 1, 1),
+                datetime(2008, 3, 15): datetime(2008, 1, 1),
+                datetime(2008, 3, 31): datetime(2008, 1, 1),
+                datetime(2008, 4, 15): datetime(2008, 4, 1),
+                datetime(2007, 7, 3): datetime(2007, 7, 2),
+                datetime(2007, 4, 3): datetime(2007, 4, 2),
+                datetime(2007, 7, 2): datetime(2007, 4, 2),
+                datetime(2008, 4, 1): datetime(2008, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterBegin(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 7, 1),
+                datetime(2008, 1, 15): datetime(2008, 7, 1),
+                datetime(2008, 2, 29): datetime(2008, 7, 1),
+                datetime(2008, 3, 15): datetime(2008, 7, 1),
+                datetime(2007, 3, 31): datetime(2007, 7, 2),
+                datetime(2007, 4, 15): datetime(2007, 10, 1),
+                datetime(2008, 4, 30): datetime(2008, 10, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestBQuarterEnd:
+    def test_repr(self):
+        expected = "<BusinessQuarterEnd: startingMonth=3>"
+        assert repr(BQuarterEnd()) == expected
+        expected = "<BusinessQuarterEnd: startingMonth=3>"
+        assert repr(BQuarterEnd(startingMonth=3)) == expected
+        expected = "<BusinessQuarterEnd: startingMonth=1>"
+        assert repr(BQuarterEnd(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "BQuarterEnd.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert BQuarterEnd(startingMonth=1).is_anchored()
+            assert BQuarterEnd().is_anchored()
+            assert not BQuarterEnd(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = BQuarterEnd(n=-1, startingMonth=1)
+        assert datetime(2010, 1, 31) + offset == datetime(2010, 1, 29)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BQuarterEnd(startingMonth=1),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 4, 30),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 7, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterEnd(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2008, 2, 15): datetime(2008, 2, 29),
+                datetime(2008, 2, 29): datetime(2008, 5, 30),
+                datetime(2008, 3, 15): datetime(2008, 5, 30),
+                datetime(2008, 3, 31): datetime(2008, 5, 30),
+                datetime(2008, 4, 15): datetime(2008, 5, 30),
+                datetime(2008, 4, 30): datetime(2008, 5, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterEnd(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 4, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterEnd(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 31),
+                datetime(2008, 1, 31): datetime(2007, 10, 31),
+                datetime(2008, 2, 15): datetime(2008, 1, 31),
+                datetime(2008, 2, 29): datetime(2008, 1, 31),
+                datetime(2008, 3, 15): datetime(2008, 1, 31),
+                datetime(2008, 3, 31): datetime(2008, 1, 31),
+                datetime(2008, 4, 15): datetime(2008, 1, 31),
+                datetime(2008, 4, 30): datetime(2008, 1, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BQuarterEnd(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 31): datetime(2008, 7, 31),
+                datetime(2008, 2, 15): datetime(2008, 7, 31),
+                datetime(2008, 2, 29): datetime(2008, 7, 31),
+                datetime(2008, 3, 15): datetime(2008, 7, 31),
+                datetime(2008, 3, 31): datetime(2008, 7, 31),
+                datetime(2008, 4, 15): datetime(2008, 7, 31),
+                datetime(2008, 4, 30): datetime(2008, 10, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (BQuarterEnd(1, startingMonth=1), datetime(2008, 1, 31), True),
+        (BQuarterEnd(1, startingMonth=1), datetime(2007, 12, 31), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2008, 2, 29), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2007, 3, 30), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2007, 3, 31), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2008, 4, 30), True),
+        (BQuarterEnd(1, startingMonth=1), datetime(2008, 5, 30), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2007, 6, 29), False),
+        (BQuarterEnd(1, startingMonth=1), datetime(2007, 6, 30), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2008, 1, 31), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2007, 12, 31), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2008, 2, 29), True),
+        (BQuarterEnd(1, startingMonth=2), datetime(2007, 3, 30), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2007, 3, 31), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2008, 4, 30), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2008, 5, 30), True),
+        (BQuarterEnd(1, startingMonth=2), datetime(2007, 6, 29), False),
+        (BQuarterEnd(1, startingMonth=2), datetime(2007, 6, 30), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2008, 1, 31), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2007, 12, 31), True),
+        (BQuarterEnd(1, startingMonth=3), datetime(2008, 2, 29), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2007, 3, 30), True),
+        (BQuarterEnd(1, startingMonth=3), datetime(2007, 3, 31), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2008, 4, 30), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2008, 5, 30), False),
+        (BQuarterEnd(1, startingMonth=3), datetime(2007, 6, 29), True),
+        (BQuarterEnd(1, startingMonth=3), datetime(2007, 6, 30), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_business_year.py

@@ -0,0 +1,215 @@
+"""
+Tests for the following offsets:
+- BYearBegin
+- BYearEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    BYearBegin,
+    BYearEnd,
+)
+
+
+class TestBYearBegin:
+    def test_misspecified(self):
+        msg = "Month must go from 1 to 12"
+        with pytest.raises(ValueError, match=msg):
+            BYearBegin(month=13)
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=13)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2009, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2011, 1, 1): datetime(2011, 1, 3),
+                datetime(2011, 1, 3): datetime(2012, 1, 2),
+                datetime(2005, 12, 30): datetime(2006, 1, 2),
+                datetime(2005, 12, 31): datetime(2006, 1, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 6, 30): datetime(2009, 1, 1),
+                datetime(2008, 12, 31): datetime(2009, 1, 1),
+                datetime(2005, 12, 30): datetime(2006, 1, 2),
+                datetime(2005, 12, 31): datetime(2006, 1, 2),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 1, 2),
+                datetime(2009, 1, 4): datetime(2009, 1, 1),
+                datetime(2009, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 6, 30): datetime(2008, 1, 1),
+                datetime(2008, 12, 31): datetime(2008, 1, 1),
+                datetime(2006, 12, 29): datetime(2006, 1, 2),
+                datetime(2006, 12, 30): datetime(2006, 1, 2),
+                datetime(2006, 1, 1): datetime(2005, 1, 3),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearBegin(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 1, 3),
+                datetime(2007, 6, 30): datetime(2006, 1, 2),
+                datetime(2008, 12, 31): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestBYearEnd:
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2009, 12, 31),
+                datetime(2005, 12, 30): datetime(2006, 12, 29),
+                datetime(2005, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 12, 31),
+                datetime(2008, 12, 31): datetime(2008, 12, 31),
+                datetime(2005, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+                datetime(2008, 6, 30): datetime(2007, 12, 31),
+                datetime(2008, 12, 31): datetime(2007, 12, 31),
+                datetime(2006, 12, 29): datetime(2005, 12, 30),
+                datetime(2006, 12, 30): datetime(2006, 12, 29),
+                datetime(2007, 1, 1): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(-2),
+            {
+                datetime(2007, 1, 1): datetime(2005, 12, 30),
+                datetime(2008, 6, 30): datetime(2006, 12, 29),
+                datetime(2008, 12, 31): datetime(2006, 12, 29),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (BYearEnd(), datetime(2007, 12, 31), True),
+        (BYearEnd(), datetime(2008, 1, 1), False),
+        (BYearEnd(), datetime(2006, 12, 31), False),
+        (BYearEnd(), datetime(2006, 12, 29), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+
+class TestBYearEndLagged:
+    def test_bad_month_fail(self):
+        msg = "Month must go from 1 to 12"
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=13)
+        with pytest.raises(ValueError, match=msg):
+            BYearEnd(month=0)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            BYearEnd(month=6),
+            {
+                datetime(2008, 1, 1): datetime(2008, 6, 30),
+                datetime(2007, 6, 30): datetime(2008, 6, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            BYearEnd(n=-1, month=6),
+            {
+                datetime(2008, 1, 1): datetime(2007, 6, 29),
+                datetime(2007, 6, 30): datetime(2007, 6, 29),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_roll(self):
+        offset = BYearEnd(month=6)
+        date = datetime(2009, 11, 30)
+
+        assert offset.rollforward(date) == datetime(2010, 6, 30)
+        assert offset.rollback(date) == datetime(2009, 6, 30)
+
+    on_offset_cases = [
+        (BYearEnd(month=2), datetime(2007, 2, 28), True),
+        (BYearEnd(month=6), datetime(2007, 6, 30), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_common.py

@@ -0,0 +1,268 @@
+from datetime import datetime
+
+from dateutil.tz.tz import tzlocal
+import pytest
+
+from pandas._libs.tslibs import (
+    OutOfBoundsDatetime,
+    Timestamp,
+)
+from pandas.compat import (
+    IS64,
+    is_platform_windows,
+)
+
+from pandas.tseries.offsets import (
+    FY5253,
+    BDay,
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BusinessHour,
+    BYearBegin,
+    BYearEnd,
+    CBMonthBegin,
+    CBMonthEnd,
+    CDay,
+    CustomBusinessHour,
+    DateOffset,
+    FY5253Quarter,
+    LastWeekOfMonth,
+    MonthBegin,
+    MonthEnd,
+    QuarterEnd,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Week,
+    WeekOfMonth,
+    YearBegin,
+    YearEnd,
+)
+
+
+def _get_offset(klass, value=1, normalize=False):
+    # create instance from offset class
+    if klass is FY5253:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is FY5253Quarter:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            qtr_with_extra_week=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is LastWeekOfMonth:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is WeekOfMonth:
+        klass = klass(n=value, week=1, weekday=5, normalize=normalize)
+    elif klass is Week:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is DateOffset:
+        klass = klass(days=value, normalize=normalize)
+    else:
+        klass = klass(value, normalize=normalize)
+    return klass
+
+
+@pytest.fixture(
+    params=[
+        BDay,
+        BusinessHour,
+        BMonthEnd,
+        BMonthBegin,
+        BQuarterEnd,
+        BQuarterBegin,
+        BYearEnd,
+        BYearBegin,
+        CDay,
+        CustomBusinessHour,
+        CBMonthEnd,
+        CBMonthBegin,
+        MonthEnd,
+        MonthBegin,
+        SemiMonthBegin,
+        SemiMonthEnd,
+        QuarterEnd,
+        LastWeekOfMonth,
+        WeekOfMonth,
+        Week,
+        YearBegin,
+        YearEnd,
+        FY5253,
+        FY5253Quarter,
+        DateOffset,
+    ]
+)
+def _offset(request):
+    return request.param
+
+
+@pytest.fixture
+def dt(_offset):
+    if _offset in (CBMonthBegin, CBMonthEnd, BDay):
+        return Timestamp(2008, 1, 1)
+    elif _offset is (CustomBusinessHour, BusinessHour):
+        return Timestamp(2014, 7, 1, 10, 00)
+    return Timestamp(2008, 1, 2)
+
+
+def test_apply_out_of_range(request, tz_naive_fixture, _offset):
+    tz = tz_naive_fixture
+
+    # try to create an out-of-bounds result timestamp; if we can't create
+    # the offset skip
+    try:
+        if _offset in (BusinessHour, CustomBusinessHour):
+            # Using 10000 in BusinessHour fails in tz check because of DST
+            # difference
+            offset = _get_offset(_offset, value=100000)
+        else:
+            offset = _get_offset(_offset, value=10000)
+
+        result = Timestamp("20080101") + offset
+        assert isinstance(result, datetime)
+        assert result.tzinfo is None
+
+        # Check tz is preserved
+        t = Timestamp("20080101", tz=tz)
+        result = t + offset
+        assert isinstance(result, datetime)
+        if tz is not None:
+            assert t.tzinfo is not None
+
+        if isinstance(tz, tzlocal) and not IS64 and _offset is not DateOffset:
+            # If we hit OutOfBoundsDatetime on non-64 bit machines
+            # we'll drop out of the try clause before the next test
+            request.applymarker(
+                pytest.mark.xfail(reason="OverflowError inside tzlocal past 2038")
+            )
+        elif (
+            isinstance(tz, tzlocal)
+            and is_platform_windows()
+            and _offset in (QuarterEnd, BQuarterBegin, BQuarterEnd)
+        ):
+            request.applymarker(
+                pytest.mark.xfail(reason="After GH#49737 t.tzinfo is None on CI")
+            )
+        assert str(t.tzinfo) == str(result.tzinfo)
+
+    except OutOfBoundsDatetime:
+        pass
+    except (ValueError, KeyError):
+        # we are creating an invalid offset
+        # so ignore
+        pass
+
+
+def test_offsets_compare_equal(_offset):
+    # root cause of GH#456: __ne__ was not implemented
+    offset1 = _offset()
+    offset2 = _offset()
+    assert not offset1 != offset2
+    assert offset1 == offset2
+
+
+@pytest.mark.parametrize(
+    "date, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay(2)],
+        [Timestamp(2014, 7, 1, 10, 00), BusinessHour(n=3)],
+        [
+            Timestamp(2014, 7, 1, 10),
+            CustomBusinessHour(
+                holidays=["2014-06-27", Timestamp(2014, 6, 30), Timestamp("2014-07-02")]
+            ),
+        ],
+        [Timestamp(2008, 1, 2), SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth(2)],
+    ],
+)
+def test_rsub(date, offset2):
+    assert date - offset2 == (-offset2)._apply(date)
+
+
+@pytest.mark.parametrize(
+    "date, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay(2)],
+        [Timestamp(2014, 7, 1, 10, 00), BusinessHour(n=3)],
+        [
+            Timestamp(2014, 7, 1, 10),
+            CustomBusinessHour(
+                holidays=["2014-06-27", Timestamp(2014, 6, 30), Timestamp("2014-07-02")]
+            ),
+        ],
+        [Timestamp(2008, 1, 2), SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth(2)],
+    ],
+)
+def test_radd(date, offset2):
+    assert date + offset2 == offset2 + date
+
+
+@pytest.mark.parametrize(
+    "date, offset_box, offset2",
+    [
+        [Timestamp(2008, 1, 1), BDay, BDay(2)],
+        [Timestamp(2008, 1, 2), SemiMonthEnd, SemiMonthEnd(2)],
+        [Timestamp(2008, 1, 2), SemiMonthBegin, SemiMonthBegin(2)],
+        [Timestamp(2008, 1, 2), Week, Week(2)],
+        [Timestamp(2008, 1, 2), WeekOfMonth, WeekOfMonth(2)],
+        [Timestamp(2008, 1, 2), LastWeekOfMonth, LastWeekOfMonth(2)],
+    ],
+)
+def test_sub(date, offset_box, offset2):
+    off = offset2
+    msg = "Cannot subtract datetime from offset"
+    with pytest.raises(TypeError, match=msg):
+        off - date
+
+    assert 2 * off - off == off
+    assert date - offset2 == date + offset_box(-2)
+    assert date - offset2 == date - (2 * off - off)
+
+
+@pytest.mark.parametrize(
+    "offset_box, offset1",
+    [
+        [BDay, BDay()],
+        [LastWeekOfMonth, LastWeekOfMonth()],
+        [WeekOfMonth, WeekOfMonth()],
+        [Week, Week()],
+        [SemiMonthBegin, SemiMonthBegin()],
+        [SemiMonthEnd, SemiMonthEnd()],
+        [CustomBusinessHour, CustomBusinessHour(weekmask="Tue Wed Thu Fri")],
+        [BusinessHour, BusinessHour()],
+    ],
+)
+def test_Mult1(offset_box, offset1):
+    dt = Timestamp(2008, 1, 2)
+    assert dt + 10 * offset1 == dt + offset_box(10)
+    assert dt + 5 * offset1 == dt + offset_box(5)
+
+
+def test_compare_str(_offset):
+    # GH#23524
+    # comparing to strings that cannot be cast to DateOffsets should
+    #  not raise for __eq__ or __ne__
+    off = _get_offset(_offset)
+
+    assert not off == "infer"
+    assert off != "foo"
+    # Note: inequalities are only implemented for Tick subclasses;
+    #  tests for this are in test_ticks

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_day.py

@@ -0,0 +1,98 @@
+"""
+Tests for offsets.CustomBusinessDay / CDay
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import CDay
+
+from pandas import (
+    _testing as tm,
+    read_pickle,
+)
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries.holiday import USFederalHolidayCalendar
+
+
+@pytest.fixture
+def offset():
+    return CDay()
+
+
+@pytest.fixture
+def offset2():
+    return CDay(2)
+
+
+class TestCustomBusinessDay:
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<CustomBusinessDay>"
+        assert repr(offset2) == "<2 * CustomBusinessDays>"
+
+        expected = "<BusinessDay: offset=datetime.timedelta(days=1)>"
+        assert repr(offset + timedelta(1)) == expected
+
+    def test_holidays(self):
+        # Define a TradingDay offset
+        holidays = ["2012-05-01", datetime(2013, 5, 1), np.datetime64("2014-05-01")]
+        tday = CDay(holidays=holidays)
+        for year in range(2012, 2015):
+            dt = datetime(year, 4, 30)
+            xp = datetime(year, 5, 2)
+            rs = dt + tday
+            assert rs == xp
+
+    def test_weekmask(self):
+        weekmask_saudi = "Sat Sun Mon Tue Wed"  # Thu-Fri Weekend
+        weekmask_uae = "1111001"  # Fri-Sat Weekend
+        weekmask_egypt = [1, 1, 1, 1, 0, 0, 1]  # Fri-Sat Weekend
+        bday_saudi = CDay(weekmask=weekmask_saudi)
+        bday_uae = CDay(weekmask=weekmask_uae)
+        bday_egypt = CDay(weekmask=weekmask_egypt)
+        dt = datetime(2013, 5, 1)
+        xp_saudi = datetime(2013, 5, 4)
+        xp_uae = datetime(2013, 5, 2)
+        xp_egypt = datetime(2013, 5, 2)
+        assert xp_saudi == dt + bday_saudi
+        assert xp_uae == dt + bday_uae
+        assert xp_egypt == dt + bday_egypt
+        xp2 = datetime(2013, 5, 5)
+        assert xp2 == dt + 2 * bday_saudi
+        assert xp2 == dt + 2 * bday_uae
+        assert xp2 == dt + 2 * bday_egypt
+
+    def test_weekmask_and_holidays(self):
+        weekmask_egypt = "Sun Mon Tue Wed Thu"  # Fri-Sat Weekend
+        holidays = ["2012-05-01", datetime(2013, 5, 1), np.datetime64("2014-05-01")]
+        bday_egypt = CDay(holidays=holidays, weekmask=weekmask_egypt)
+        dt = datetime(2013, 4, 30)
+        xp_egypt = datetime(2013, 5, 5)
+        assert xp_egypt == dt + 2 * bday_egypt
+
+    @pytest.mark.filterwarnings("ignore:Non:pandas.errors.PerformanceWarning")
+    def test_calendar(self):
+        calendar = USFederalHolidayCalendar()
+        dt = datetime(2014, 1, 17)
+        assert_offset_equal(CDay(calendar=calendar), dt, datetime(2014, 1, 21))
+
+    def test_roundtrip_pickle(self, offset, offset2):
+        def _check_roundtrip(obj):
+            unpickled = tm.round_trip_pickle(obj)
+            assert unpickled == obj
+
+        _check_roundtrip(offset)
+        _check_roundtrip(offset2)
+        _check_roundtrip(offset * 2)
+
+    def test_pickle_compat_0_14_1(self, datapath):
+        hdays = [datetime(2013, 1, 1) for ele in range(4)]
+        pth = datapath("tseries", "offsets", "data", "cday-0.14.1.pickle")
+        cday0_14_1 = read_pickle(pth)
+        cday = CDay(holidays=hdays)
+        assert cday == cday0_14_1

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_hour.py

@@ -0,0 +1,329 @@
+"""
+Tests for offsets.CustomBusinessHour
+"""
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    time as dt_time,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.offsets import (
+    BusinessHour,
+    CustomBusinessHour,
+    Nano,
+)
+
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries.holiday import USFederalHolidayCalendar
+
+holidays = ["2014-06-27", datetime(2014, 6, 30), np.datetime64("2014-07-02")]
+
+
+@pytest.fixture
+def dt():
+    return datetime(2014, 7, 1, 10, 00)
+
+
+@pytest.fixture
+def _offset():
+    return CustomBusinessHour
+
+
+# 2014 Calendar to check custom holidays
+#   Sun Mon Tue Wed Thu Fri Sat
+#  6/22  23  24  25  26  27  28
+#    29  30 7/1   2   3   4   5
+#     6   7   8   9  10  11  12
+@pytest.fixture
+def offset1():
+    return CustomBusinessHour(weekmask="Tue Wed Thu Fri")
+
+
+@pytest.fixture
+def offset2():
+    return CustomBusinessHour(holidays=holidays)
+
+
+class TestCustomBusinessHour:
+    def test_constructor_errors(self):
+        msg = "time data must be specified only with hour and minute"
+        with pytest.raises(ValueError, match=msg):
+            CustomBusinessHour(start=dt_time(11, 0, 5))
+        msg = "time data must match '%H:%M' format"
+        with pytest.raises(ValueError, match=msg):
+            CustomBusinessHour(start="AAA")
+        msg = "time data must match '%H:%M' format"
+        with pytest.raises(ValueError, match=msg):
+            CustomBusinessHour(start="14:00:05")
+
+    def test_different_normalize_equals(self, _offset):
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
+        offset = _offset()
+        offset2 = _offset(normalize=True)
+        assert offset != offset2
+
+    def test_repr(self, offset1, offset2):
+        assert repr(offset1) == "<CustomBusinessHour: cbh=09:00-17:00>"
+        assert repr(offset2) == "<CustomBusinessHour: cbh=09:00-17:00>"
+
+    def test_with_offset(self, dt):
+        expected = Timestamp("2014-07-01 13:00")
+
+        assert dt + CustomBusinessHour() * 3 == expected
+        assert dt + CustomBusinessHour(n=3) == expected
+
+    def test_eq(self, offset1, offset2):
+        for offset in [offset1, offset2]:
+            assert offset == offset
+
+        assert CustomBusinessHour() != CustomBusinessHour(-1)
+        assert CustomBusinessHour(start="09:00") == CustomBusinessHour()
+        assert CustomBusinessHour(start="09:00") != CustomBusinessHour(start="09:01")
+        assert CustomBusinessHour(start="09:00", end="17:00") != CustomBusinessHour(
+            start="17:00", end="09:01"
+        )
+
+        assert CustomBusinessHour(weekmask="Tue Wed Thu Fri") != CustomBusinessHour(
+            weekmask="Mon Tue Wed Thu Fri"
+        )
+        assert CustomBusinessHour(holidays=["2014-06-27"]) != CustomBusinessHour(
+            holidays=["2014-06-28"]
+        )
+
+    def test_hash(self, offset1, offset2):
+        assert hash(offset1) == hash(offset1)
+        assert hash(offset2) == hash(offset2)
+
+    def test_add_dateime(self, dt, offset1, offset2):
+        assert offset1 + dt == datetime(2014, 7, 1, 11)
+        assert offset2 + dt == datetime(2014, 7, 1, 11)
+
+    def testRollback1(self, dt, offset1, offset2):
+        assert offset1.rollback(dt) == dt
+        assert offset2.rollback(dt) == dt
+
+        d = datetime(2014, 7, 1, 0)
+
+        # 2014/07/01 is Tuesday, 06/30 is Monday(holiday)
+        assert offset1.rollback(d) == datetime(2014, 6, 27, 17)
+
+        # 2014/6/30 and 2014/6/27 are holidays
+        assert offset2.rollback(d) == datetime(2014, 6, 26, 17)
+
+    def testRollback2(self, _offset):
+        assert _offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime(
+            2014, 7, 4, 17, 0
+        )
+
+    def testRollforward1(self, dt, offset1, offset2):
+        assert offset1.rollforward(dt) == dt
+        assert offset2.rollforward(dt) == dt
+
+        d = datetime(2014, 7, 1, 0)
+        assert offset1.rollforward(d) == datetime(2014, 7, 1, 9)
+        assert offset2.rollforward(d) == datetime(2014, 7, 1, 9)
+
+    def testRollforward2(self, _offset):
+        assert _offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime(
+            2014, 7, 7, 9
+        )
+
+    def test_roll_date_object(self):
+        offset = BusinessHour()
+
+        dt = datetime(2014, 7, 6, 15, 0)
+
+        result = offset.rollback(dt)
+        assert result == datetime(2014, 7, 4, 17)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2014, 7, 7, 9)
+
+    normalize_cases = [
+        (
+            CustomBusinessHour(normalize=True, holidays=holidays),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 3),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 3),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 3),
+                datetime(2014, 7, 1, 0): datetime(2014, 7, 1),
+                datetime(2014, 7, 4, 15): datetime(2014, 7, 4),
+                datetime(2014, 7, 4, 15, 59): datetime(2014, 7, 4),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7),
+                datetime(2014, 7, 5, 23): datetime(2014, 7, 7),
+                datetime(2014, 7, 6, 10): datetime(2014, 7, 7),
+            },
+        ),
+        (
+            CustomBusinessHour(-1, normalize=True, holidays=holidays),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 6, 26),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 10): datetime(2014, 6, 26),
+                datetime(2014, 7, 1, 0): datetime(2014, 6, 26),
+                datetime(2014, 7, 7, 10): datetime(2014, 7, 4),
+                datetime(2014, 7, 7, 10, 1): datetime(2014, 7, 7),
+                datetime(2014, 7, 5, 23): datetime(2014, 7, 4),
+                datetime(2014, 7, 6, 10): datetime(2014, 7, 4),
+            },
+        ),
+        (
+            CustomBusinessHour(
+                1, normalize=True, start="17:00", end="04:00", holidays=holidays
+            ),
+            {
+                datetime(2014, 7, 1, 8): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 1),
+                datetime(2014, 7, 1, 23): datetime(2014, 7, 2),
+                datetime(2014, 7, 2, 2): datetime(2014, 7, 2),
+                datetime(2014, 7, 2, 3): datetime(2014, 7, 3),
+                datetime(2014, 7, 4, 23): datetime(2014, 7, 5),
+                datetime(2014, 7, 5, 2): datetime(2014, 7, 5),
+                datetime(2014, 7, 7, 2): datetime(2014, 7, 7),
+                datetime(2014, 7, 7, 17): datetime(2014, 7, 7),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("norm_cases", normalize_cases)
+    def test_normalize(self, norm_cases):
+        offset, cases = norm_cases
+        for dt, expected in cases.items():
+            assert offset._apply(dt) == expected
+
+    @pytest.mark.parametrize(
+        "dt, expected",
+        [
+            [datetime(2014, 7, 1, 9), False],
+            [datetime(2014, 7, 1, 10), True],
+            [datetime(2014, 7, 1, 15), True],
+            [datetime(2014, 7, 1, 15, 1), False],
+            [datetime(2014, 7, 5, 12), False],
+            [datetime(2014, 7, 6, 12), False],
+        ],
+    )
+    def test_is_on_offset(self, dt, expected):
+        offset = CustomBusinessHour(start="10:00", end="15:00", holidays=holidays)
+        assert offset.is_on_offset(dt) == expected
+
+    apply_cases = [
+        (
+            CustomBusinessHour(holidays=holidays),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 12),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 1, 14),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 1, 16),
+                datetime(2014, 7, 1, 19): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 3, 9),
+                datetime(2014, 7, 1, 16, 30, 15): datetime(2014, 7, 3, 9, 30, 15),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 3, 10),
+                # out of business hours
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 10),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 10),
+                # saturday
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 10),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 10),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7, 9, 30),
+                datetime(2014, 7, 4, 16, 30, 30): datetime(2014, 7, 7, 9, 30, 30),
+            },
+        ),
+        (
+            CustomBusinessHour(4, holidays=holidays),
+            {
+                datetime(2014, 7, 1, 11): datetime(2014, 7, 1, 15),
+                datetime(2014, 7, 1, 13): datetime(2014, 7, 3, 9),
+                datetime(2014, 7, 1, 15): datetime(2014, 7, 3, 11),
+                datetime(2014, 7, 1, 16): datetime(2014, 7, 3, 12),
+                datetime(2014, 7, 1, 17): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 11): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 8): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 19): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 2, 23): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 3, 0): datetime(2014, 7, 3, 13),
+                datetime(2014, 7, 5, 15): datetime(2014, 7, 7, 13),
+                datetime(2014, 7, 4, 17): datetime(2014, 7, 7, 13),
+                datetime(2014, 7, 4, 16, 30): datetime(2014, 7, 7, 12, 30),
+                datetime(2014, 7, 4, 16, 30, 30): datetime(2014, 7, 7, 12, 30, 30),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("apply_case", apply_cases)
+    def test_apply(self, apply_case):
+        offset, cases = apply_case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    nano_cases = [
+        (
+            CustomBusinessHour(holidays=holidays),
+            {
+                Timestamp("2014-07-01 15:00")
+                + Nano(5): Timestamp("2014-07-01 16:00")
+                + Nano(5),
+                Timestamp("2014-07-01 16:00")
+                + Nano(5): Timestamp("2014-07-03 09:00")
+                + Nano(5),
+                Timestamp("2014-07-01 16:00")
+                - Nano(5): Timestamp("2014-07-01 17:00")
+                - Nano(5),
+            },
+        ),
+        (
+            CustomBusinessHour(-1, holidays=holidays),
+            {
+                Timestamp("2014-07-01 15:00")
+                + Nano(5): Timestamp("2014-07-01 14:00")
+                + Nano(5),
+                Timestamp("2014-07-01 10:00")
+                + Nano(5): Timestamp("2014-07-01 09:00")
+                + Nano(5),
+                Timestamp("2014-07-01 10:00")
+                - Nano(5): Timestamp("2014-06-26 17:00")
+                - Nano(5),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("nano_case", nano_cases)
+    def test_apply_nanoseconds(self, nano_case):
+        offset, cases = nano_case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_us_federal_holiday_with_datetime(self):
+        # GH 16867
+        bhour_us = CustomBusinessHour(calendar=USFederalHolidayCalendar())
+        t0 = datetime(2014, 1, 17, 15)
+        result = t0 + bhour_us * 8
+        expected = Timestamp("2014-01-21 15:00:00")
+        assert result == expected
+
+
+@pytest.mark.parametrize(
+    "weekmask, expected_time, mult",
+    [
+        ["Mon Tue Wed Thu Fri Sat", "2018-11-10 09:00:00", 10],
+        ["Tue Wed Thu Fri Sat", "2018-11-13 08:00:00", 18],
+    ],
+)
+def test_custom_businesshour_weekmask_and_holidays(weekmask, expected_time, mult):
+    # GH 23542
+    holidays = ["2018-11-09"]
+    bh = CustomBusinessHour(
+        start="08:00", end="17:00", weekmask=weekmask, holidays=holidays
+    )
+    result = Timestamp("2018-11-08 08:00") + mult * bh
+    expected = Timestamp(expected_time)
+    assert result == expected

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_custom_business_month.py

@@ -0,0 +1,437 @@
+"""
+Tests for the following offsets:
+- CustomBusinessMonthBase
+- CustomBusinessMonthBegin
+- CustomBusinessMonthEnd
+"""
+from __future__ import annotations
+
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import (
+    CBMonthBegin,
+    CBMonthEnd,
+    CDay,
+)
+
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries import offsets
+
+
+@pytest.fixture
+def dt():
+    return datetime(2008, 1, 1)
+
+
+class TestCommonCBM:
+    @pytest.mark.parametrize("offset2", [CBMonthBegin(2), CBMonthEnd(2)])
+    def test_eq(self, offset2):
+        assert offset2 == offset2
+
+    @pytest.mark.parametrize("offset2", [CBMonthBegin(2), CBMonthEnd(2)])
+    def test_hash(self, offset2):
+        assert hash(offset2) == hash(offset2)
+
+    @pytest.mark.parametrize("_offset", [CBMonthBegin, CBMonthEnd])
+    def test_roundtrip_pickle(self, _offset):
+        def _check_roundtrip(obj):
+            unpickled = tm.round_trip_pickle(obj)
+            assert unpickled == obj
+
+        _check_roundtrip(_offset())
+        _check_roundtrip(_offset(2))
+        _check_roundtrip(_offset() * 2)
+
+    @pytest.mark.parametrize("_offset", [CBMonthBegin, CBMonthEnd])
+    def test_copy(self, _offset):
+        # GH 17452
+        off = _offset(weekmask="Mon Wed Fri")
+        assert off == off.copy()
+
+
+class TestCustomBusinessMonthBegin:
+    @pytest.fixture
+    def _offset(self):
+        return CBMonthBegin
+
+    @pytest.fixture
+    def offset(self):
+        return CBMonthBegin()
+
+    @pytest.fixture
+    def offset2(self):
+        return CBMonthBegin(2)
+
+    def test_different_normalize_equals(self, _offset):
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
+        offset = _offset()
+        offset2 = _offset(normalize=True)
+        assert offset != offset2
+
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<CustomBusinessMonthBegin>"
+        assert repr(offset2) == "<2 * CustomBusinessMonthBegins>"
+
+    def test_add_datetime(self, dt, offset2):
+        assert offset2 + dt == datetime(2008, 3, 3)
+
+    def testRollback1(self):
+        assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
+
+    def testRollback2(self, dt):
+        assert CBMonthBegin(10).rollback(dt) == datetime(2008, 1, 1)
+
+    def testRollforward1(self, dt):
+        assert CBMonthBegin(10).rollforward(dt) == datetime(2008, 1, 1)
+
+    def test_roll_date_object(self):
+        offset = CBMonthBegin()
+
+        dt = date(2012, 9, 15)
+
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 9, 3)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 10, 1)
+
+        offset = offsets.Day()
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 9, 15)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 9, 15)
+
+    on_offset_cases = [
+        (CBMonthBegin(), datetime(2008, 1, 1), True),
+        (CBMonthBegin(), datetime(2008, 1, 31), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    apply_cases = [
+        (
+            CBMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 2, 7): datetime(2008, 3, 3),
+            },
+        ),
+        (
+            2 * CBMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 3, 3),
+                datetime(2008, 2, 7): datetime(2008, 4, 1),
+            },
+        ),
+        (
+            -CBMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2007, 12, 3),
+                datetime(2008, 2, 8): datetime(2008, 2, 1),
+            },
+        ),
+        (
+            -2 * CBMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2007, 11, 1),
+                datetime(2008, 2, 9): datetime(2008, 1, 1),
+            },
+        ),
+        (
+            CBMonthBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 7): datetime(2008, 2, 1),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", apply_cases)
+    def test_apply(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_apply_large_n(self):
+        dt = datetime(2012, 10, 23)
+
+        result = dt + CBMonthBegin(10)
+        assert result == datetime(2013, 8, 1)
+
+        result = dt + CDay(100) - CDay(100)
+        assert result == dt
+
+        off = CBMonthBegin() * 6
+        rs = datetime(2012, 1, 1) - off
+        xp = datetime(2011, 7, 1)
+        assert rs == xp
+
+        st = datetime(2011, 12, 18)
+        rs = st + off
+
+        xp = datetime(2012, 6, 1)
+        assert rs == xp
+
+    def test_holidays(self):
+        # Define a TradingDay offset
+        holidays = ["2012-02-01", datetime(2012, 2, 2), np.datetime64("2012-03-01")]
+        bm_offset = CBMonthBegin(holidays=holidays)
+        dt = datetime(2012, 1, 1)
+
+        assert dt + bm_offset == datetime(2012, 1, 2)
+        assert dt + 2 * bm_offset == datetime(2012, 2, 3)
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            (
+                CBMonthBegin(n=1, offset=timedelta(days=5)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 4, 1) + timedelta(days=5),
+                    datetime(2021, 4, 17): datetime(2021, 5, 3) + timedelta(days=5),
+                },
+            ),
+            (
+                CBMonthBegin(n=2, offset=timedelta(days=40)),
+                {
+                    datetime(2021, 3, 10): datetime(2021, 5, 3) + timedelta(days=40),
+                    datetime(2021, 4, 30): datetime(2021, 6, 1) + timedelta(days=40),
+                },
+            ),
+            (
+                CBMonthBegin(n=1, offset=timedelta(days=-5)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 4, 1) - timedelta(days=5),
+                    datetime(2021, 4, 11): datetime(2021, 5, 3) - timedelta(days=5),
+                },
+            ),
+            (
+                -2 * CBMonthBegin(n=1, offset=timedelta(days=10)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 1, 1) + timedelta(days=10),
+                    datetime(2021, 4, 3): datetime(2021, 3, 1) + timedelta(days=10),
+                },
+            ),
+            (
+                CBMonthBegin(n=0, offset=timedelta(days=1)),
+                {
+                    datetime(2021, 3, 2): datetime(2021, 4, 1) + timedelta(days=1),
+                    datetime(2021, 4, 1): datetime(2021, 4, 1) + timedelta(days=1),
+                },
+            ),
+            (
+                CBMonthBegin(
+                    n=1, holidays=["2021-04-01", "2021-04-02"], offset=timedelta(days=1)
+                ),
+                {
+                    datetime(2021, 3, 2): datetime(2021, 4, 5) + timedelta(days=1),
+                },
+            ),
+        ],
+    )
+    def test_apply_with_extra_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestCustomBusinessMonthEnd:
+    @pytest.fixture
+    def _offset(self):
+        return CBMonthEnd
+
+    @pytest.fixture
+    def offset(self):
+        return CBMonthEnd()
+
+    @pytest.fixture
+    def offset2(self):
+        return CBMonthEnd(2)
+
+    def test_different_normalize_equals(self, _offset):
+        # GH#21404 changed __eq__ to return False when `normalize` does not match
+        offset = _offset()
+        offset2 = _offset(normalize=True)
+        assert offset != offset2
+
+    def test_repr(self, offset, offset2):
+        assert repr(offset) == "<CustomBusinessMonthEnd>"
+        assert repr(offset2) == "<2 * CustomBusinessMonthEnds>"
+
+    def test_add_datetime(self, dt, offset2):
+        assert offset2 + dt == datetime(2008, 2, 29)
+
+    def testRollback1(self):
+        assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
+
+    def testRollback2(self, dt):
+        assert CBMonthEnd(10).rollback(dt) == datetime(2007, 12, 31)
+
+    def testRollforward1(self, dt):
+        assert CBMonthEnd(10).rollforward(dt) == datetime(2008, 1, 31)
+
+    def test_roll_date_object(self):
+        offset = CBMonthEnd()
+
+        dt = date(2012, 9, 15)
+
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 8, 31)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 9, 28)
+
+        offset = offsets.Day()
+        result = offset.rollback(dt)
+        assert result == datetime(2012, 9, 15)
+
+        result = offset.rollforward(dt)
+        assert result == datetime(2012, 9, 15)
+
+    on_offset_cases = [
+        (CBMonthEnd(), datetime(2008, 1, 31), True),
+        (CBMonthEnd(), datetime(2008, 1, 1), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    apply_cases = [
+        (
+            CBMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 2, 7): datetime(2008, 2, 29),
+            },
+        ),
+        (
+            2 * CBMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 2, 7): datetime(2008, 3, 31),
+            },
+        ),
+        (
+            -CBMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2007, 12, 31),
+                datetime(2008, 2, 8): datetime(2008, 1, 31),
+            },
+        ),
+        (
+            -2 * CBMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2007, 11, 30),
+                datetime(2008, 2, 9): datetime(2007, 12, 31),
+            },
+        ),
+        (
+            CBMonthEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 2, 7): datetime(2008, 2, 29),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", apply_cases)
+    def test_apply(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    def test_apply_large_n(self):
+        dt = datetime(2012, 10, 23)
+
+        result = dt + CBMonthEnd(10)
+        assert result == datetime(2013, 7, 31)
+
+        result = dt + CDay(100) - CDay(100)
+        assert result == dt
+
+        off = CBMonthEnd() * 6
+        rs = datetime(2012, 1, 1) - off
+        xp = datetime(2011, 7, 29)
+        assert rs == xp
+
+        st = datetime(2011, 12, 18)
+        rs = st + off
+        xp = datetime(2012, 5, 31)
+        assert rs == xp
+
+    def test_holidays(self):
+        # Define a TradingDay offset
+        holidays = ["2012-01-31", datetime(2012, 2, 28), np.datetime64("2012-02-29")]
+        bm_offset = CBMonthEnd(holidays=holidays)
+        dt = datetime(2012, 1, 1)
+        assert dt + bm_offset == datetime(2012, 1, 30)
+        assert dt + 2 * bm_offset == datetime(2012, 2, 27)
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            (
+                CBMonthEnd(n=1, offset=timedelta(days=5)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 3, 31) + timedelta(days=5),
+                    datetime(2021, 4, 17): datetime(2021, 4, 30) + timedelta(days=5),
+                },
+            ),
+            (
+                CBMonthEnd(n=2, offset=timedelta(days=40)),
+                {
+                    datetime(2021, 3, 10): datetime(2021, 4, 30) + timedelta(days=40),
+                    datetime(2021, 4, 30): datetime(2021, 6, 30) + timedelta(days=40),
+                },
+            ),
+            (
+                CBMonthEnd(n=1, offset=timedelta(days=-5)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 3, 31) - timedelta(days=5),
+                    datetime(2021, 4, 11): datetime(2021, 4, 30) - timedelta(days=5),
+                },
+            ),
+            (
+                -2 * CBMonthEnd(n=1, offset=timedelta(days=10)),
+                {
+                    datetime(2021, 3, 1): datetime(2021, 1, 29) + timedelta(days=10),
+                    datetime(2021, 4, 3): datetime(2021, 2, 26) + timedelta(days=10),
+                },
+            ),
+            (
+                CBMonthEnd(n=0, offset=timedelta(days=1)),
+                {
+                    datetime(2021, 3, 2): datetime(2021, 3, 31) + timedelta(days=1),
+                    datetime(2021, 4, 1): datetime(2021, 4, 30) + timedelta(days=1),
+                },
+            ),
+            (
+                CBMonthEnd(n=1, holidays=["2021-03-31"], offset=timedelta(days=1)),
+                {
+                    datetime(2021, 3, 2): datetime(2021, 3, 30) + timedelta(days=1),
+                },
+            ),
+        ],
+    )
+    def test_apply_with_extra_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_dst.py

@@ -0,0 +1,260 @@
+"""
+Tests for DateOffset additions over Daylight Savings Time
+"""
+from datetime import timedelta
+
+import pytest
+import pytz
+
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.offsets import (
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BYearBegin,
+    BYearEnd,
+    CBMonthBegin,
+    CBMonthEnd,
+    CustomBusinessDay,
+    DateOffset,
+    Day,
+    MonthBegin,
+    MonthEnd,
+    QuarterBegin,
+    QuarterEnd,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Week,
+    YearBegin,
+    YearEnd,
+)
+from pandas.errors import PerformanceWarning
+
+from pandas import DatetimeIndex
+import pandas._testing as tm
+from pandas.util.version import Version
+
+# error: Module has no attribute "__version__"
+pytz_version = Version(pytz.__version__)  # type: ignore[attr-defined]
+
+
+def get_utc_offset_hours(ts):
+    # take a Timestamp and compute total hours of utc offset
+    o = ts.utcoffset()
+    return (o.days * 24 * 3600 + o.seconds) / 3600.0
+
+
+class TestDST:
+    # one microsecond before the DST transition
+    ts_pre_fallback = "2013-11-03 01:59:59.999999"
+    ts_pre_springfwd = "2013-03-10 01:59:59.999999"
+
+    # test both basic names and dateutil timezones
+    timezone_utc_offsets = {
+        "US/Eastern": {"utc_offset_daylight": -4, "utc_offset_standard": -5},
+        "dateutil/US/Pacific": {"utc_offset_daylight": -7, "utc_offset_standard": -8},
+    }
+    valid_date_offsets_singular = [
+        "weekday",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "microsecond",
+    ]
+    valid_date_offsets_plural = [
+        "weeks",
+        "days",
+        "hours",
+        "minutes",
+        "seconds",
+        "milliseconds",
+        "microseconds",
+    ]
+
+    def _test_all_offsets(self, n, **kwds):
+        valid_offsets = (
+            self.valid_date_offsets_plural
+            if n > 1
+            else self.valid_date_offsets_singular
+        )
+
+        for name in valid_offsets:
+            self._test_offset(offset_name=name, offset_n=n, **kwds)
+
+    def _test_offset(self, offset_name, offset_n, tstart, expected_utc_offset):
+        offset = DateOffset(**{offset_name: offset_n})
+
+        if (
+            offset_name in ["hour", "minute", "second", "microsecond"]
+            and offset_n == 1
+            and tstart == Timestamp("2013-11-03 01:59:59.999999-0500", tz="US/Eastern")
+        ):
+            # This addition results in an ambiguous wall time
+            err_msg = {
+                "hour": "2013-11-03 01:59:59.999999",
+                "minute": "2013-11-03 01:01:59.999999",
+                "second": "2013-11-03 01:59:01.999999",
+                "microsecond": "2013-11-03 01:59:59.000001",
+            }[offset_name]
+            with pytest.raises(pytz.AmbiguousTimeError, match=err_msg):
+                tstart + offset
+            # While we're here, let's check that we get the same behavior in a
+            #  vectorized path
+            dti = DatetimeIndex([tstart])
+            warn_msg = "Non-vectorized DateOffset"
+            with pytest.raises(pytz.AmbiguousTimeError, match=err_msg):
+                with tm.assert_produces_warning(PerformanceWarning, match=warn_msg):
+                    dti + offset
+            return
+
+        t = tstart + offset
+        if expected_utc_offset is not None:
+            assert get_utc_offset_hours(t) == expected_utc_offset
+
+        if offset_name == "weeks":
+            # dates should match
+            assert t.date() == timedelta(days=7 * offset.kwds["weeks"]) + tstart.date()
+            # expect the same day of week, hour of day, minute, second, ...
+            assert (
+                t.dayofweek == tstart.dayofweek
+                and t.hour == tstart.hour
+                and t.minute == tstart.minute
+                and t.second == tstart.second
+            )
+        elif offset_name == "days":
+            # dates should match
+            assert timedelta(offset.kwds["days"]) + tstart.date() == t.date()
+            # expect the same hour of day, minute, second, ...
+            assert (
+                t.hour == tstart.hour
+                and t.minute == tstart.minute
+                and t.second == tstart.second
+            )
+        elif offset_name in self.valid_date_offsets_singular:
+            # expect the singular offset value to match between tstart and t
+            datepart_offset = getattr(
+                t, offset_name if offset_name != "weekday" else "dayofweek"
+            )
+            assert datepart_offset == offset.kwds[offset_name]
+        else:
+            # the offset should be the same as if it was done in UTC
+            assert t == (tstart.tz_convert("UTC") + offset).tz_convert("US/Pacific")
+
+    def _make_timestamp(self, string, hrs_offset, tz):
+        if hrs_offset >= 0:
+            offset_string = f"{hrs_offset:02d}00"
+        else:
+            offset_string = f"-{(hrs_offset * -1):02}00"
+        return Timestamp(string + offset_string).tz_convert(tz)
+
+    def test_springforward_plural(self):
+        # test moving from standard to daylight savings
+        for tz, utc_offsets in self.timezone_utc_offsets.items():
+            hrs_pre = utc_offsets["utc_offset_standard"]
+            hrs_post = utc_offsets["utc_offset_daylight"]
+            self._test_all_offsets(
+                n=3,
+                tstart=self._make_timestamp(self.ts_pre_springfwd, hrs_pre, tz),
+                expected_utc_offset=hrs_post,
+            )
+
+    def test_fallback_singular(self):
+        # in the case of singular offsets, we don't necessarily know which utc
+        # offset the new Timestamp will wind up in (the tz for 1 month may be
+        # different from 1 second) so we don't specify an expected_utc_offset
+        for tz, utc_offsets in self.timezone_utc_offsets.items():
+            hrs_pre = utc_offsets["utc_offset_standard"]
+            self._test_all_offsets(
+                n=1,
+                tstart=self._make_timestamp(self.ts_pre_fallback, hrs_pre, tz),
+                expected_utc_offset=None,
+            )
+
+    def test_springforward_singular(self):
+        for tz, utc_offsets in self.timezone_utc_offsets.items():
+            hrs_pre = utc_offsets["utc_offset_standard"]
+            self._test_all_offsets(
+                n=1,
+                tstart=self._make_timestamp(self.ts_pre_springfwd, hrs_pre, tz),
+                expected_utc_offset=None,
+            )
+
+    offset_classes = {
+        MonthBegin: ["11/2/2012", "12/1/2012"],
+        MonthEnd: ["11/2/2012", "11/30/2012"],
+        BMonthBegin: ["11/2/2012", "12/3/2012"],
+        BMonthEnd: ["11/2/2012", "11/30/2012"],
+        CBMonthBegin: ["11/2/2012", "12/3/2012"],
+        CBMonthEnd: ["11/2/2012", "11/30/2012"],
+        SemiMonthBegin: ["11/2/2012", "11/15/2012"],
+        SemiMonthEnd: ["11/2/2012", "11/15/2012"],
+        Week: ["11/2/2012", "11/9/2012"],
+        YearBegin: ["11/2/2012", "1/1/2013"],
+        YearEnd: ["11/2/2012", "12/31/2012"],
+        BYearBegin: ["11/2/2012", "1/1/2013"],
+        BYearEnd: ["11/2/2012", "12/31/2012"],
+        QuarterBegin: ["11/2/2012", "12/1/2012"],
+        QuarterEnd: ["11/2/2012", "12/31/2012"],
+        BQuarterBegin: ["11/2/2012", "12/3/2012"],
+        BQuarterEnd: ["11/2/2012", "12/31/2012"],
+        Day: ["11/4/2012", "11/4/2012 23:00"],
+    }.items()
+
+    @pytest.mark.parametrize("tup", offset_classes)
+    def test_all_offset_classes(self, tup):
+        offset, test_values = tup
+
+        first = Timestamp(test_values[0], tz="US/Eastern") + offset()
+        second = Timestamp(test_values[1], tz="US/Eastern")
+        assert first == second
+
+
+@pytest.mark.parametrize(
+    "original_dt, target_dt, offset, tz",
+    [
+        pytest.param(
+            Timestamp("1900-01-01"),
+            Timestamp("1905-07-01"),
+            MonthBegin(66),
+            "Africa/Lagos",
+            marks=pytest.mark.xfail(
+                pytz_version < Version("2020.5") or pytz_version == Version("2022.2"),
+                reason="GH#41906: pytz utc transition dates changed",
+            ),
+        ),
+        (
+            Timestamp("2021-10-01 01:15"),
+            Timestamp("2021-10-31 01:15"),
+            MonthEnd(1),
+            "Europe/London",
+        ),
+        (
+            Timestamp("2010-12-05 02:59"),
+            Timestamp("2010-10-31 02:59"),
+            SemiMonthEnd(-3),
+            "Europe/Paris",
+        ),
+        (
+            Timestamp("2021-10-31 01:20"),
+            Timestamp("2021-11-07 01:20"),
+            CustomBusinessDay(2, weekmask="Sun Mon"),
+            "US/Eastern",
+        ),
+        (
+            Timestamp("2020-04-03 01:30"),
+            Timestamp("2020-11-01 01:30"),
+            YearBegin(1, month=11),
+            "America/Chicago",
+        ),
+    ],
+)
+def test_nontick_offset_with_ambiguous_time_error(original_dt, target_dt, offset, tz):
+    # .apply for non-Tick offsets throws AmbiguousTimeError when the target dt
+    # is dst-ambiguous
+    localized_dt = original_dt.tz_localize(tz)
+
+    msg = f"Cannot infer dst time from {target_dt}, try using the 'ambiguous' argument"
+    with pytest.raises(pytz.AmbiguousTimeError, match=msg):
+        localized_dt + offset

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_easter.py

@@ -0,0 +1,33 @@
+"""
+Tests for the following offsets:
+- Easter
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries.offsets import Easter
+
+
+class TestEaster:
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (Easter(), datetime(2010, 1, 1), datetime(2010, 4, 4)),
+            (Easter(), datetime(2010, 4, 5), datetime(2011, 4, 24)),
+            (Easter(2), datetime(2010, 1, 1), datetime(2011, 4, 24)),
+            (Easter(), datetime(2010, 4, 4), datetime(2011, 4, 24)),
+            (Easter(2), datetime(2010, 4, 4), datetime(2012, 4, 8)),
+            (-Easter(), datetime(2011, 1, 1), datetime(2010, 4, 4)),
+            (-Easter(), datetime(2010, 4, 5), datetime(2010, 4, 4)),
+            (-Easter(2), datetime(2011, 1, 1), datetime(2009, 4, 12)),
+            (-Easter(), datetime(2010, 4, 4), datetime(2009, 4, 12)),
+            (-Easter(2), datetime(2010, 4, 4), datetime(2008, 3, 23)),
+        ],
+    )
+    def test_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_fiscal.py

@@ -0,0 +1,656 @@
+"""
+Tests for Fiscal Year and Fiscal Quarter offset classes
+"""
+from datetime import datetime
+
+from dateutil.relativedelta import relativedelta
+import pytest
+
+from pandas import Timestamp
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    WeekDay,
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    FY5253,
+    FY5253Quarter,
+)
+
+
+def makeFY5253LastOfMonthQuarter(*args, **kwds):
+    return FY5253Quarter(*args, variation="last", **kwds)
+
+
+def makeFY5253NearestEndMonthQuarter(*args, **kwds):
+    return FY5253Quarter(*args, variation="nearest", **kwds)
+
+
+def makeFY5253NearestEndMonth(*args, **kwds):
+    return FY5253(*args, variation="nearest", **kwds)
+
+
+def makeFY5253LastOfMonth(*args, **kwds):
+    return FY5253(*args, variation="last", **kwds)
+
+
+def test_get_offset_name():
+    assert (
+        makeFY5253LastOfMonthQuarter(
+            weekday=1, startingMonth=3, qtr_with_extra_week=4
+        ).freqstr
+        == "REQ-L-MAR-TUE-4"
+    )
+    assert (
+        makeFY5253NearestEndMonthQuarter(
+            weekday=1, startingMonth=3, qtr_with_extra_week=3
+        ).freqstr
+        == "REQ-N-MAR-TUE-3"
+    )
+
+
+class TestFY5253LastOfMonth:
+    offset_lom_sat_aug = makeFY5253LastOfMonth(1, startingMonth=8, weekday=WeekDay.SAT)
+    offset_lom_sat_sep = makeFY5253LastOfMonth(1, startingMonth=9, weekday=WeekDay.SAT)
+
+    on_offset_cases = [
+        # From Wikipedia (see:
+        # https://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar#Last_Saturday_of_the_month_at_fiscal_year_end)
+        (offset_lom_sat_aug, datetime(2006, 8, 26), True),
+        (offset_lom_sat_aug, datetime(2007, 8, 25), True),
+        (offset_lom_sat_aug, datetime(2008, 8, 30), True),
+        (offset_lom_sat_aug, datetime(2009, 8, 29), True),
+        (offset_lom_sat_aug, datetime(2010, 8, 28), True),
+        (offset_lom_sat_aug, datetime(2011, 8, 27), True),
+        (offset_lom_sat_aug, datetime(2012, 8, 25), True),
+        (offset_lom_sat_aug, datetime(2013, 8, 31), True),
+        (offset_lom_sat_aug, datetime(2014, 8, 30), True),
+        (offset_lom_sat_aug, datetime(2015, 8, 29), True),
+        (offset_lom_sat_aug, datetime(2016, 8, 27), True),
+        (offset_lom_sat_aug, datetime(2017, 8, 26), True),
+        (offset_lom_sat_aug, datetime(2018, 8, 25), True),
+        (offset_lom_sat_aug, datetime(2019, 8, 31), True),
+        (offset_lom_sat_aug, datetime(2006, 8, 27), False),
+        (offset_lom_sat_aug, datetime(2007, 8, 28), False),
+        (offset_lom_sat_aug, datetime(2008, 8, 31), False),
+        (offset_lom_sat_aug, datetime(2009, 8, 30), False),
+        (offset_lom_sat_aug, datetime(2010, 8, 29), False),
+        (offset_lom_sat_aug, datetime(2011, 8, 28), False),
+        (offset_lom_sat_aug, datetime(2006, 8, 25), False),
+        (offset_lom_sat_aug, datetime(2007, 8, 24), False),
+        (offset_lom_sat_aug, datetime(2008, 8, 29), False),
+        (offset_lom_sat_aug, datetime(2009, 8, 28), False),
+        (offset_lom_sat_aug, datetime(2010, 8, 27), False),
+        (offset_lom_sat_aug, datetime(2011, 8, 26), False),
+        (offset_lom_sat_aug, datetime(2019, 8, 30), False),
+        # From GMCR (see for example:
+        # http://yahoo.brand.edgar-online.com/Default.aspx?
+        # companyid=3184&formtypeID=7)
+        (offset_lom_sat_sep, datetime(2010, 9, 25), True),
+        (offset_lom_sat_sep, datetime(2011, 9, 24), True),
+        (offset_lom_sat_sep, datetime(2012, 9, 29), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    def test_apply(self):
+        offset_lom_aug_sat = makeFY5253LastOfMonth(startingMonth=8, weekday=WeekDay.SAT)
+        offset_lom_aug_sat_1 = makeFY5253LastOfMonth(
+            n=1, startingMonth=8, weekday=WeekDay.SAT
+        )
+
+        date_seq_lom_aug_sat = [
+            datetime(2006, 8, 26),
+            datetime(2007, 8, 25),
+            datetime(2008, 8, 30),
+            datetime(2009, 8, 29),
+            datetime(2010, 8, 28),
+            datetime(2011, 8, 27),
+            datetime(2012, 8, 25),
+            datetime(2013, 8, 31),
+            datetime(2014, 8, 30),
+            datetime(2015, 8, 29),
+            datetime(2016, 8, 27),
+        ]
+
+        tests = [
+            (offset_lom_aug_sat, date_seq_lom_aug_sat),
+            (offset_lom_aug_sat_1, date_seq_lom_aug_sat),
+            (offset_lom_aug_sat, [datetime(2006, 8, 25)] + date_seq_lom_aug_sat),
+            (offset_lom_aug_sat_1, [datetime(2006, 8, 27)] + date_seq_lom_aug_sat[1:]),
+            (
+                makeFY5253LastOfMonth(n=-1, startingMonth=8, weekday=WeekDay.SAT),
+                list(reversed(date_seq_lom_aug_sat)),
+            ),
+        ]
+        for test in tests:
+            offset, data = test
+            current = data[0]
+            for datum in data[1:]:
+                current = current + offset
+                assert current == datum
+
+
+class TestFY5253NearestEndMonth:
+    def test_get_year_end(self):
+        assert makeFY5253NearestEndMonth(
+            startingMonth=8, weekday=WeekDay.SAT
+        ).get_year_end(datetime(2013, 1, 1)) == datetime(2013, 8, 31)
+        assert makeFY5253NearestEndMonth(
+            startingMonth=8, weekday=WeekDay.SUN
+        ).get_year_end(datetime(2013, 1, 1)) == datetime(2013, 9, 1)
+        assert makeFY5253NearestEndMonth(
+            startingMonth=8, weekday=WeekDay.FRI
+        ).get_year_end(datetime(2013, 1, 1)) == datetime(2013, 8, 30)
+
+        offset_n = FY5253(weekday=WeekDay.TUE, startingMonth=12, variation="nearest")
+        assert offset_n.get_year_end(datetime(2012, 1, 1)) == datetime(2013, 1, 1)
+        assert offset_n.get_year_end(datetime(2012, 1, 10)) == datetime(2013, 1, 1)
+
+        assert offset_n.get_year_end(datetime(2013, 1, 1)) == datetime(2013, 12, 31)
+        assert offset_n.get_year_end(datetime(2013, 1, 2)) == datetime(2013, 12, 31)
+        assert offset_n.get_year_end(datetime(2013, 1, 3)) == datetime(2013, 12, 31)
+        assert offset_n.get_year_end(datetime(2013, 1, 10)) == datetime(2013, 12, 31)
+
+        JNJ = FY5253(n=1, startingMonth=12, weekday=6, variation="nearest")
+        assert JNJ.get_year_end(datetime(2006, 1, 1)) == datetime(2006, 12, 31)
+
+    offset_lom_aug_sat = makeFY5253NearestEndMonth(
+        1, startingMonth=8, weekday=WeekDay.SAT
+    )
+    offset_lom_aug_thu = makeFY5253NearestEndMonth(
+        1, startingMonth=8, weekday=WeekDay.THU
+    )
+    offset_n = FY5253(weekday=WeekDay.TUE, startingMonth=12, variation="nearest")
+
+    on_offset_cases = [
+        #    From Wikipedia (see:
+        #    https://en.wikipedia.org/wiki/4%E2%80%934%E2%80%935_calendar
+        #    #Saturday_nearest_the_end_of_month)
+        #    2006-09-02   2006 September 2
+        #    2007-09-01   2007 September 1
+        #    2008-08-30   2008 August 30    (leap year)
+        #    2009-08-29   2009 August 29
+        #    2010-08-28   2010 August 28
+        #    2011-09-03   2011 September 3
+        #    2012-09-01   2012 September 1  (leap year)
+        #    2013-08-31   2013 August 31
+        #    2014-08-30   2014 August 30
+        #    2015-08-29   2015 August 29
+        #    2016-09-03   2016 September 3  (leap year)
+        #    2017-09-02   2017 September 2
+        #    2018-09-01   2018 September 1
+        #    2019-08-31   2019 August 31
+        (offset_lom_aug_sat, datetime(2006, 9, 2), True),
+        (offset_lom_aug_sat, datetime(2007, 9, 1), True),
+        (offset_lom_aug_sat, datetime(2008, 8, 30), True),
+        (offset_lom_aug_sat, datetime(2009, 8, 29), True),
+        (offset_lom_aug_sat, datetime(2010, 8, 28), True),
+        (offset_lom_aug_sat, datetime(2011, 9, 3), True),
+        (offset_lom_aug_sat, datetime(2016, 9, 3), True),
+        (offset_lom_aug_sat, datetime(2017, 9, 2), True),
+        (offset_lom_aug_sat, datetime(2018, 9, 1), True),
+        (offset_lom_aug_sat, datetime(2019, 8, 31), True),
+        (offset_lom_aug_sat, datetime(2006, 8, 27), False),
+        (offset_lom_aug_sat, datetime(2007, 8, 28), False),
+        (offset_lom_aug_sat, datetime(2008, 8, 31), False),
+        (offset_lom_aug_sat, datetime(2009, 8, 30), False),
+        (offset_lom_aug_sat, datetime(2010, 8, 29), False),
+        (offset_lom_aug_sat, datetime(2011, 8, 28), False),
+        (offset_lom_aug_sat, datetime(2006, 8, 25), False),
+        (offset_lom_aug_sat, datetime(2007, 8, 24), False),
+        (offset_lom_aug_sat, datetime(2008, 8, 29), False),
+        (offset_lom_aug_sat, datetime(2009, 8, 28), False),
+        (offset_lom_aug_sat, datetime(2010, 8, 27), False),
+        (offset_lom_aug_sat, datetime(2011, 8, 26), False),
+        (offset_lom_aug_sat, datetime(2019, 8, 30), False),
+        # From Micron, see:
+        # http://google.brand.edgar-online.com/?sym=MU&formtypeID=7
+        (offset_lom_aug_thu, datetime(2012, 8, 30), True),
+        (offset_lom_aug_thu, datetime(2011, 9, 1), True),
+        (offset_n, datetime(2012, 12, 31), False),
+        (offset_n, datetime(2013, 1, 1), True),
+        (offset_n, datetime(2013, 1, 2), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    def test_apply(self):
+        date_seq_nem_8_sat = [
+            datetime(2006, 9, 2),
+            datetime(2007, 9, 1),
+            datetime(2008, 8, 30),
+            datetime(2009, 8, 29),
+            datetime(2010, 8, 28),
+            datetime(2011, 9, 3),
+        ]
+
+        JNJ = [
+            datetime(2005, 1, 2),
+            datetime(2006, 1, 1),
+            datetime(2006, 12, 31),
+            datetime(2007, 12, 30),
+            datetime(2008, 12, 28),
+            datetime(2010, 1, 3),
+            datetime(2011, 1, 2),
+            datetime(2012, 1, 1),
+            datetime(2012, 12, 30),
+        ]
+
+        DEC_SAT = FY5253(n=-1, startingMonth=12, weekday=5, variation="nearest")
+
+        tests = [
+            (
+                makeFY5253NearestEndMonth(startingMonth=8, weekday=WeekDay.SAT),
+                date_seq_nem_8_sat,
+            ),
+            (
+                makeFY5253NearestEndMonth(n=1, startingMonth=8, weekday=WeekDay.SAT),
+                date_seq_nem_8_sat,
+            ),
+            (
+                makeFY5253NearestEndMonth(startingMonth=8, weekday=WeekDay.SAT),
+                [datetime(2006, 9, 1)] + date_seq_nem_8_sat,
+            ),
+            (
+                makeFY5253NearestEndMonth(n=1, startingMonth=8, weekday=WeekDay.SAT),
+                [datetime(2006, 9, 3)] + date_seq_nem_8_sat[1:],
+            ),
+            (
+                makeFY5253NearestEndMonth(n=-1, startingMonth=8, weekday=WeekDay.SAT),
+                list(reversed(date_seq_nem_8_sat)),
+            ),
+            (
+                makeFY5253NearestEndMonth(n=1, startingMonth=12, weekday=WeekDay.SUN),
+                JNJ,
+            ),
+            (
+                makeFY5253NearestEndMonth(n=-1, startingMonth=12, weekday=WeekDay.SUN),
+                list(reversed(JNJ)),
+            ),
+            (
+                makeFY5253NearestEndMonth(n=1, startingMonth=12, weekday=WeekDay.SUN),
+                [datetime(2005, 1, 2), datetime(2006, 1, 1)],
+            ),
+            (
+                makeFY5253NearestEndMonth(n=1, startingMonth=12, weekday=WeekDay.SUN),
+                [datetime(2006, 1, 2), datetime(2006, 12, 31)],
+            ),
+            (DEC_SAT, [datetime(2013, 1, 15), datetime(2012, 12, 29)]),
+        ]
+        for test in tests:
+            offset, data = test
+            current = data[0]
+            for datum in data[1:]:
+                current = current + offset
+                assert current == datum
+
+
+class TestFY5253LastOfMonthQuarter:
+    def test_is_anchored(self):
+        msg = "FY5253Quarter.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert makeFY5253LastOfMonthQuarter(
+                startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+            ).is_anchored()
+            assert makeFY5253LastOfMonthQuarter(
+                weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
+            ).is_anchored()
+            assert not makeFY5253LastOfMonthQuarter(
+                2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+            ).is_anchored()
+
+    def test_equality(self):
+        assert makeFY5253LastOfMonthQuarter(
+            startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        ) == makeFY5253LastOfMonthQuarter(
+            startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+        assert makeFY5253LastOfMonthQuarter(
+            startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        ) != makeFY5253LastOfMonthQuarter(
+            startingMonth=1, weekday=WeekDay.SUN, qtr_with_extra_week=4
+        )
+        assert makeFY5253LastOfMonthQuarter(
+            startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        ) != makeFY5253LastOfMonthQuarter(
+            startingMonth=2, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+
+    def test_offset(self):
+        offset = makeFY5253LastOfMonthQuarter(
+            1, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+        offset2 = makeFY5253LastOfMonthQuarter(
+            2, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+        offset4 = makeFY5253LastOfMonthQuarter(
+            4, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+
+        offset_neg1 = makeFY5253LastOfMonthQuarter(
+            -1, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+        offset_neg2 = makeFY5253LastOfMonthQuarter(
+            -2, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+
+        GMCR = [
+            datetime(2010, 3, 27),
+            datetime(2010, 6, 26),
+            datetime(2010, 9, 25),
+            datetime(2010, 12, 25),
+            datetime(2011, 3, 26),
+            datetime(2011, 6, 25),
+            datetime(2011, 9, 24),
+            datetime(2011, 12, 24),
+            datetime(2012, 3, 24),
+            datetime(2012, 6, 23),
+            datetime(2012, 9, 29),
+            datetime(2012, 12, 29),
+            datetime(2013, 3, 30),
+            datetime(2013, 6, 29),
+        ]
+
+        assert_offset_equal(offset, base=GMCR[0], expected=GMCR[1])
+        assert_offset_equal(
+            offset, base=GMCR[0] + relativedelta(days=-1), expected=GMCR[0]
+        )
+        assert_offset_equal(offset, base=GMCR[1], expected=GMCR[2])
+
+        assert_offset_equal(offset2, base=GMCR[0], expected=GMCR[2])
+        assert_offset_equal(offset4, base=GMCR[0], expected=GMCR[4])
+
+        assert_offset_equal(offset_neg1, base=GMCR[-1], expected=GMCR[-2])
+        assert_offset_equal(
+            offset_neg1, base=GMCR[-1] + relativedelta(days=+1), expected=GMCR[-1]
+        )
+        assert_offset_equal(offset_neg2, base=GMCR[-1], expected=GMCR[-3])
+
+        date = GMCR[0] + relativedelta(days=-1)
+        for expected in GMCR:
+            assert_offset_equal(offset, date, expected)
+            date = date + offset
+
+        date = GMCR[-1] + relativedelta(days=+1)
+        for expected in reversed(GMCR):
+            assert_offset_equal(offset_neg1, date, expected)
+            date = date + offset_neg1
+
+    lomq_aug_sat_4 = makeFY5253LastOfMonthQuarter(
+        1, startingMonth=8, weekday=WeekDay.SAT, qtr_with_extra_week=4
+    )
+    lomq_sep_sat_4 = makeFY5253LastOfMonthQuarter(
+        1, startingMonth=9, weekday=WeekDay.SAT, qtr_with_extra_week=4
+    )
+
+    on_offset_cases = [
+        # From Wikipedia
+        (lomq_aug_sat_4, datetime(2006, 8, 26), True),
+        (lomq_aug_sat_4, datetime(2007, 8, 25), True),
+        (lomq_aug_sat_4, datetime(2008, 8, 30), True),
+        (lomq_aug_sat_4, datetime(2009, 8, 29), True),
+        (lomq_aug_sat_4, datetime(2010, 8, 28), True),
+        (lomq_aug_sat_4, datetime(2011, 8, 27), True),
+        (lomq_aug_sat_4, datetime(2019, 8, 31), True),
+        (lomq_aug_sat_4, datetime(2006, 8, 27), False),
+        (lomq_aug_sat_4, datetime(2007, 8, 28), False),
+        (lomq_aug_sat_4, datetime(2008, 8, 31), False),
+        (lomq_aug_sat_4, datetime(2009, 8, 30), False),
+        (lomq_aug_sat_4, datetime(2010, 8, 29), False),
+        (lomq_aug_sat_4, datetime(2011, 8, 28), False),
+        (lomq_aug_sat_4, datetime(2006, 8, 25), False),
+        (lomq_aug_sat_4, datetime(2007, 8, 24), False),
+        (lomq_aug_sat_4, datetime(2008, 8, 29), False),
+        (lomq_aug_sat_4, datetime(2009, 8, 28), False),
+        (lomq_aug_sat_4, datetime(2010, 8, 27), False),
+        (lomq_aug_sat_4, datetime(2011, 8, 26), False),
+        (lomq_aug_sat_4, datetime(2019, 8, 30), False),
+        # From GMCR
+        (lomq_sep_sat_4, datetime(2010, 9, 25), True),
+        (lomq_sep_sat_4, datetime(2011, 9, 24), True),
+        (lomq_sep_sat_4, datetime(2012, 9, 29), True),
+        (lomq_sep_sat_4, datetime(2013, 6, 29), True),
+        (lomq_sep_sat_4, datetime(2012, 6, 23), True),
+        (lomq_sep_sat_4, datetime(2012, 6, 30), False),
+        (lomq_sep_sat_4, datetime(2013, 3, 30), True),
+        (lomq_sep_sat_4, datetime(2012, 3, 24), True),
+        (lomq_sep_sat_4, datetime(2012, 12, 29), True),
+        (lomq_sep_sat_4, datetime(2011, 12, 24), True),
+        # INTC (extra week in Q1)
+        # See: http://www.intc.com/releasedetail.cfm?ReleaseID=542844
+        (
+            makeFY5253LastOfMonthQuarter(
+                1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+            ),
+            datetime(2011, 4, 2),
+            True,
+        ),
+        # see: http://google.brand.edgar-online.com/?sym=INTC&formtypeID=7
+        (
+            makeFY5253LastOfMonthQuarter(
+                1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+            ),
+            datetime(2012, 12, 29),
+            True,
+        ),
+        (
+            makeFY5253LastOfMonthQuarter(
+                1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+            ),
+            datetime(2011, 12, 31),
+            True,
+        ),
+        (
+            makeFY5253LastOfMonthQuarter(
+                1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+            ),
+            datetime(2010, 12, 25),
+            True,
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    def test_year_has_extra_week(self):
+        # End of long Q1
+        assert makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(2011, 4, 2))
+
+        # Start of long Q1
+        assert makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(2010, 12, 26))
+
+        # End of year before year with long Q1
+        assert not makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(2010, 12, 25))
+
+        for year in [
+            x for x in range(1994, 2011 + 1) if x not in [2011, 2005, 2000, 1994]
+        ]:
+            assert not makeFY5253LastOfMonthQuarter(
+                1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+            ).year_has_extra_week(datetime(year, 4, 2))
+
+        # Other long years
+        assert makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(2005, 4, 2))
+
+        assert makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(2000, 4, 2))
+
+        assert makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        ).year_has_extra_week(datetime(1994, 4, 2))
+
+    def test_get_weeks(self):
+        sat_dec_1 = makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=1
+        )
+        sat_dec_4 = makeFY5253LastOfMonthQuarter(
+            1, startingMonth=12, weekday=WeekDay.SAT, qtr_with_extra_week=4
+        )
+
+        assert sat_dec_1.get_weeks(datetime(2011, 4, 2)) == [14, 13, 13, 13]
+        assert sat_dec_4.get_weeks(datetime(2011, 4, 2)) == [13, 13, 13, 14]
+        assert sat_dec_1.get_weeks(datetime(2010, 12, 25)) == [13, 13, 13, 13]
+
+
+class TestFY5253NearestEndMonthQuarter:
+    offset_nem_sat_aug_4 = makeFY5253NearestEndMonthQuarter(
+        1, startingMonth=8, weekday=WeekDay.SAT, qtr_with_extra_week=4
+    )
+    offset_nem_thu_aug_4 = makeFY5253NearestEndMonthQuarter(
+        1, startingMonth=8, weekday=WeekDay.THU, qtr_with_extra_week=4
+    )
+    offset_n = FY5253(weekday=WeekDay.TUE, startingMonth=12, variation="nearest")
+
+    on_offset_cases = [
+        # From Wikipedia
+        (offset_nem_sat_aug_4, datetime(2006, 9, 2), True),
+        (offset_nem_sat_aug_4, datetime(2007, 9, 1), True),
+        (offset_nem_sat_aug_4, datetime(2008, 8, 30), True),
+        (offset_nem_sat_aug_4, datetime(2009, 8, 29), True),
+        (offset_nem_sat_aug_4, datetime(2010, 8, 28), True),
+        (offset_nem_sat_aug_4, datetime(2011, 9, 3), True),
+        (offset_nem_sat_aug_4, datetime(2016, 9, 3), True),
+        (offset_nem_sat_aug_4, datetime(2017, 9, 2), True),
+        (offset_nem_sat_aug_4, datetime(2018, 9, 1), True),
+        (offset_nem_sat_aug_4, datetime(2019, 8, 31), True),
+        (offset_nem_sat_aug_4, datetime(2006, 8, 27), False),
+        (offset_nem_sat_aug_4, datetime(2007, 8, 28), False),
+        (offset_nem_sat_aug_4, datetime(2008, 8, 31), False),
+        (offset_nem_sat_aug_4, datetime(2009, 8, 30), False),
+        (offset_nem_sat_aug_4, datetime(2010, 8, 29), False),
+        (offset_nem_sat_aug_4, datetime(2011, 8, 28), False),
+        (offset_nem_sat_aug_4, datetime(2006, 8, 25), False),
+        (offset_nem_sat_aug_4, datetime(2007, 8, 24), False),
+        (offset_nem_sat_aug_4, datetime(2008, 8, 29), False),
+        (offset_nem_sat_aug_4, datetime(2009, 8, 28), False),
+        (offset_nem_sat_aug_4, datetime(2010, 8, 27), False),
+        (offset_nem_sat_aug_4, datetime(2011, 8, 26), False),
+        (offset_nem_sat_aug_4, datetime(2019, 8, 30), False),
+        # From Micron, see:
+        # http://google.brand.edgar-online.com/?sym=MU&formtypeID=7
+        (offset_nem_thu_aug_4, datetime(2012, 8, 30), True),
+        (offset_nem_thu_aug_4, datetime(2011, 9, 1), True),
+        # See: http://google.brand.edgar-online.com/?sym=MU&formtypeID=13
+        (offset_nem_thu_aug_4, datetime(2013, 5, 30), True),
+        (offset_nem_thu_aug_4, datetime(2013, 2, 28), True),
+        (offset_nem_thu_aug_4, datetime(2012, 11, 29), True),
+        (offset_nem_thu_aug_4, datetime(2012, 5, 31), True),
+        (offset_nem_thu_aug_4, datetime(2007, 3, 1), True),
+        (offset_nem_thu_aug_4, datetime(1994, 3, 3), True),
+        (offset_n, datetime(2012, 12, 31), False),
+        (offset_n, datetime(2013, 1, 1), True),
+        (offset_n, datetime(2013, 1, 2), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)
+
+    def test_offset(self):
+        offset = makeFY5253NearestEndMonthQuarter(
+            1, startingMonth=8, weekday=WeekDay.THU, qtr_with_extra_week=4
+        )
+
+        MU = [
+            datetime(2012, 5, 31),
+            datetime(2012, 8, 30),
+            datetime(2012, 11, 29),
+            datetime(2013, 2, 28),
+            datetime(2013, 5, 30),
+        ]
+
+        date = MU[0] + relativedelta(days=-1)
+        for expected in MU:
+            assert_offset_equal(offset, date, expected)
+            date = date + offset
+
+        assert_offset_equal(offset, datetime(2012, 5, 31), datetime(2012, 8, 30))
+        assert_offset_equal(offset, datetime(2012, 5, 30), datetime(2012, 5, 31))
+
+        offset2 = FY5253Quarter(
+            weekday=5, startingMonth=12, variation="last", qtr_with_extra_week=4
+        )
+
+        assert_offset_equal(offset2, datetime(2013, 1, 15), datetime(2013, 3, 30))
+
+
+def test_bunched_yearends():
+    # GH#14774 cases with two fiscal year-ends in the same calendar-year
+    fy = FY5253(n=1, weekday=5, startingMonth=12, variation="nearest")
+    dt = Timestamp("2004-01-01")
+    assert fy.rollback(dt) == Timestamp("2002-12-28")
+    assert (-fy)._apply(dt) == Timestamp("2002-12-28")
+    assert dt - fy == Timestamp("2002-12-28")
+
+    assert fy.rollforward(dt) == Timestamp("2004-01-03")
+    assert fy._apply(dt) == Timestamp("2004-01-03")
+    assert fy + dt == Timestamp("2004-01-03")
+    assert dt + fy == Timestamp("2004-01-03")
+
+    # Same thing, but starting from a Timestamp in the previous year.
+    dt = Timestamp("2003-12-31")
+    assert fy.rollback(dt) == Timestamp("2002-12-28")
+    assert (-fy)._apply(dt) == Timestamp("2002-12-28")
+    assert dt - fy == Timestamp("2002-12-28")
+
+
+def test_fy5253_last_onoffset():
+    # GH#18877 dates on the year-end but not normalized to midnight
+    offset = FY5253(n=-5, startingMonth=5, variation="last", weekday=0)
+    ts = Timestamp("1984-05-28 06:29:43.955911354+0200", tz="Europe/San_Marino")
+    fast = offset.is_on_offset(ts)
+    slow = (ts + offset) - offset == ts
+    assert fast == slow
+
+
+def test_fy5253_nearest_onoffset():
+    # GH#18877 dates on the year-end but not normalized to midnight
+    offset = FY5253(n=3, startingMonth=7, variation="nearest", weekday=2)
+    ts = Timestamp("2032-07-28 00:12:59.035729419+0000", tz="Africa/Dakar")
+    fast = offset.is_on_offset(ts)
+    slow = (ts + offset) - offset == ts
+    assert fast == slow
+
+
+def test_fy5253qtr_onoffset_nearest():
+    # GH#19036
+    ts = Timestamp("1985-09-02 23:57:46.232550356-0300", tz="Atlantic/Bermuda")
+    offset = FY5253Quarter(
+        n=3, qtr_with_extra_week=1, startingMonth=2, variation="nearest", weekday=0
+    )
+    fast = offset.is_on_offset(ts)
+    slow = (ts + offset) - offset == ts
+    assert fast == slow
+
+
+def test_fy5253qtr_onoffset_last():
+    # GH#19036
+    offset = FY5253Quarter(
+        n=-2, qtr_with_extra_week=1, startingMonth=7, variation="last", weekday=2
+    )
+    ts = Timestamp("2011-01-26 19:03:40.331096129+0200", tz="Africa/Windhoek")
+    slow = (ts + offset) - offset == ts
+    fast = offset.is_on_offset(ts)
+    assert fast == slow

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_index.py

@@ -0,0 +1,57 @@
+"""
+Tests for offset behavior with indices.
+"""
+import pytest
+
+from pandas import (
+    Series,
+    date_range,
+)
+
+from pandas.tseries.offsets import (
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BYearBegin,
+    BYearEnd,
+    MonthBegin,
+    MonthEnd,
+    QuarterBegin,
+    QuarterEnd,
+    YearBegin,
+    YearEnd,
+)
+
+
+@pytest.mark.parametrize("n", [-2, 1])
+@pytest.mark.parametrize(
+    "cls",
+    [
+        MonthBegin,
+        MonthEnd,
+        BMonthBegin,
+        BMonthEnd,
+        QuarterBegin,
+        QuarterEnd,
+        BQuarterBegin,
+        BQuarterEnd,
+        YearBegin,
+        YearEnd,
+        BYearBegin,
+        BYearEnd,
+    ],
+)
+def test_apply_index(cls, n):
+    offset = cls(n=n)
+    rng = date_range(start="1/1/2000", periods=100000, freq="min")
+    ser = Series(rng)
+
+    res = rng + offset
+    assert res.freq is None  # not retained
+    assert res[0] == rng[0] + offset
+    assert res[-1] == rng[-1] + offset
+    res2 = ser + offset
+    # apply_index is only for indexes, not series, so no res2_v2
+    assert res2.iloc[0] == ser.iloc[0] + offset
+    assert res2.iloc[-1] == ser.iloc[-1] + offset

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_month.py

@@ -0,0 +1,666 @@
+"""
+Tests for the following offsets:
+- SemiMonthBegin
+- SemiMonthEnd
+- MonthBegin
+- MonthEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas._libs.tslibs.offsets import (
+    MonthBegin,
+    MonthEnd,
+    SemiMonthBegin,
+    SemiMonthEnd,
+)
+
+from pandas import (
+    DatetimeIndex,
+    Series,
+    _testing as tm,
+)
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+
+class TestSemiMonthEnd:
+    def test_offset_whole_year(self):
+        dates = (
+            datetime(2007, 12, 31),
+            datetime(2008, 1, 15),
+            datetime(2008, 1, 31),
+            datetime(2008, 2, 15),
+            datetime(2008, 2, 29),
+            datetime(2008, 3, 15),
+            datetime(2008, 3, 31),
+            datetime(2008, 4, 15),
+            datetime(2008, 4, 30),
+            datetime(2008, 5, 15),
+            datetime(2008, 5, 31),
+            datetime(2008, 6, 15),
+            datetime(2008, 6, 30),
+            datetime(2008, 7, 15),
+            datetime(2008, 7, 31),
+            datetime(2008, 8, 15),
+            datetime(2008, 8, 31),
+            datetime(2008, 9, 15),
+            datetime(2008, 9, 30),
+            datetime(2008, 10, 15),
+            datetime(2008, 10, 31),
+            datetime(2008, 11, 15),
+            datetime(2008, 11, 30),
+            datetime(2008, 12, 15),
+            datetime(2008, 12, 31),
+        )
+
+        for base, exp_date in zip(dates[:-1], dates[1:]):
+            assert_offset_equal(SemiMonthEnd(), base, exp_date)
+
+        # ensure .apply_index works as expected
+        shift = DatetimeIndex(dates[:-1])
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = SemiMonthEnd() + shift
+
+        exp = DatetimeIndex(dates[1:])
+        tm.assert_index_equal(result, exp)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            SemiMonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 15),
+                datetime(2008, 1, 15): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 2, 15),
+                datetime(2006, 12, 14): datetime(2006, 12, 15),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2007, 1, 15),
+                datetime(2007, 1, 1): datetime(2007, 1, 15),
+                datetime(2006, 12, 1): datetime(2006, 12, 15),
+                datetime(2006, 12, 15): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(day_of_month=20),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 20),
+                datetime(2008, 1, 15): datetime(2008, 1, 20),
+                datetime(2008, 1, 21): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 2, 20),
+                datetime(2006, 12, 14): datetime(2006, 12, 20),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2007, 1, 20),
+                datetime(2007, 1, 1): datetime(2007, 1, 20),
+                datetime(2006, 12, 1): datetime(2006, 12, 20),
+                datetime(2006, 12, 15): datetime(2006, 12, 20),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 15),
+                datetime(2008, 1, 16): datetime(2008, 1, 31),
+                datetime(2008, 1, 15): datetime(2008, 1, 15),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2006, 12, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 15),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(0, day_of_month=16),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 16),
+                datetime(2008, 1, 16): datetime(2008, 1, 16),
+                datetime(2008, 1, 15): datetime(2008, 1, 16),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2006, 12, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 16),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2006, 12, 29): datetime(2007, 1, 15),
+                datetime(2006, 12, 31): datetime(2007, 1, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 31),
+                datetime(2007, 1, 16): datetime(2007, 2, 15),
+                datetime(2006, 11, 1): datetime(2006, 11, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 6, 15),
+                datetime(2008, 12, 31): datetime(2008, 12, 15),
+                datetime(2006, 12, 29): datetime(2006, 12, 15),
+                datetime(2006, 12, 30): datetime(2006, 12, 15),
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(-1, day_of_month=4),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+                datetime(2007, 1, 4): datetime(2006, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 6, 4),
+                datetime(2008, 12, 31): datetime(2008, 12, 4),
+                datetime(2006, 12, 5): datetime(2006, 12, 4),
+                datetime(2006, 12, 30): datetime(2006, 12, 4),
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            SemiMonthEnd(-2),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 15),
+                datetime(2008, 6, 30): datetime(2008, 5, 31),
+                datetime(2008, 3, 15): datetime(2008, 2, 15),
+                datetime(2008, 12, 31): datetime(2008, 11, 30),
+                datetime(2006, 12, 29): datetime(2006, 11, 30),
+                datetime(2006, 12, 14): datetime(2006, 11, 15),
+                datetime(2007, 1, 1): datetime(2006, 12, 15),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_apply_index(self, case):
+        # https://github.com/pandas-dev/pandas/issues/34580
+        offset, cases = case
+        shift = DatetimeIndex(cases.keys())
+        exp = DatetimeIndex(cases.values())
+
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = offset + shift
+        tm.assert_index_equal(result, exp)
+
+    on_offset_cases = [
+        (datetime(2007, 12, 31), True),
+        (datetime(2007, 12, 15), True),
+        (datetime(2007, 12, 14), False),
+        (datetime(2007, 12, 1), False),
+        (datetime(2008, 2, 29), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        dt, expected = case
+        assert_is_on_offset(SemiMonthEnd(), dt, expected)
+
+    @pytest.mark.parametrize("klass", [Series, DatetimeIndex])
+    def test_vectorized_offset_addition(self, klass):
+        shift = klass(
+            [
+                Timestamp("2000-01-15 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-15", tz="US/Central"),
+            ],
+            name="a",
+        )
+
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = shift + SemiMonthEnd()
+            result2 = SemiMonthEnd() + shift
+
+        exp = klass(
+            [
+                Timestamp("2000-01-31 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-29", tz="US/Central"),
+            ],
+            name="a",
+        )
+        tm.assert_equal(result, exp)
+        tm.assert_equal(result2, exp)
+
+        shift = klass(
+            [
+                Timestamp("2000-01-01 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-01", tz="US/Central"),
+            ],
+            name="a",
+        )
+
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = shift + SemiMonthEnd()
+            result2 = SemiMonthEnd() + shift
+
+        exp = klass(
+            [
+                Timestamp("2000-01-15 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-15", tz="US/Central"),
+            ],
+            name="a",
+        )
+        tm.assert_equal(result, exp)
+        tm.assert_equal(result2, exp)
+
+
+class TestSemiMonthBegin:
+    def test_offset_whole_year(self):
+        dates = (
+            datetime(2007, 12, 15),
+            datetime(2008, 1, 1),
+            datetime(2008, 1, 15),
+            datetime(2008, 2, 1),
+            datetime(2008, 2, 15),
+            datetime(2008, 3, 1),
+            datetime(2008, 3, 15),
+            datetime(2008, 4, 1),
+            datetime(2008, 4, 15),
+            datetime(2008, 5, 1),
+            datetime(2008, 5, 15),
+            datetime(2008, 6, 1),
+            datetime(2008, 6, 15),
+            datetime(2008, 7, 1),
+            datetime(2008, 7, 15),
+            datetime(2008, 8, 1),
+            datetime(2008, 8, 15),
+            datetime(2008, 9, 1),
+            datetime(2008, 9, 15),
+            datetime(2008, 10, 1),
+            datetime(2008, 10, 15),
+            datetime(2008, 11, 1),
+            datetime(2008, 11, 15),
+            datetime(2008, 12, 1),
+            datetime(2008, 12, 15),
+        )
+
+        for base, exp_date in zip(dates[:-1], dates[1:]):
+            assert_offset_equal(SemiMonthBegin(), base, exp_date)
+
+        # ensure .apply_index works as expected
+        shift = DatetimeIndex(dates[:-1])
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = SemiMonthBegin() + shift
+
+        exp = DatetimeIndex(dates[1:])
+        tm.assert_index_equal(result, exp)
+
+    offset_cases = [
+        (
+            SemiMonthBegin(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 15),
+                datetime(2008, 1, 15): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 14): datetime(2006, 12, 15),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2007, 1, 1): datetime(2007, 1, 15),
+                datetime(2006, 12, 1): datetime(2006, 12, 15),
+                datetime(2006, 12, 15): datetime(2007, 1, 1),
+            },
+        ),
+        (
+            SemiMonthBegin(day_of_month=20),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 20),
+                datetime(2008, 1, 15): datetime(2008, 1, 20),
+                datetime(2008, 1, 21): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 14): datetime(2006, 12, 20),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2007, 1, 1): datetime(2007, 1, 20),
+                datetime(2006, 12, 1): datetime(2006, 12, 20),
+                datetime(2006, 12, 15): datetime(2006, 12, 20),
+            },
+        ),
+        (
+            SemiMonthBegin(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 16): datetime(2008, 2, 1),
+                datetime(2008, 1, 15): datetime(2008, 1, 15),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 2): datetime(2006, 12, 15),
+                datetime(2007, 1, 1): datetime(2007, 1, 1),
+            },
+        ),
+        (
+            SemiMonthBegin(0, day_of_month=16),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 16): datetime(2008, 1, 16),
+                datetime(2008, 1, 15): datetime(2008, 1, 16),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2006, 12, 29): datetime(2007, 1, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2007, 1, 5): datetime(2007, 1, 16),
+                datetime(2007, 1, 1): datetime(2007, 1, 1),
+            },
+        ),
+        (
+            SemiMonthBegin(2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 15),
+                datetime(2006, 12, 1): datetime(2007, 1, 1),
+                datetime(2006, 12, 29): datetime(2007, 1, 15),
+                datetime(2006, 12, 15): datetime(2007, 1, 15),
+                datetime(2007, 1, 1): datetime(2007, 2, 1),
+                datetime(2007, 1, 16): datetime(2007, 2, 15),
+                datetime(2006, 11, 1): datetime(2006, 12, 1),
+            },
+        ),
+        (
+            SemiMonthBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 15),
+                datetime(2008, 6, 30): datetime(2008, 6, 15),
+                datetime(2008, 6, 14): datetime(2008, 6, 1),
+                datetime(2008, 12, 31): datetime(2008, 12, 15),
+                datetime(2006, 12, 29): datetime(2006, 12, 15),
+                datetime(2006, 12, 15): datetime(2006, 12, 1),
+                datetime(2007, 1, 1): datetime(2006, 12, 15),
+            },
+        ),
+        (
+            SemiMonthBegin(-1, day_of_month=4),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 4),
+                datetime(2007, 1, 4): datetime(2007, 1, 1),
+                datetime(2008, 6, 30): datetime(2008, 6, 4),
+                datetime(2008, 12, 31): datetime(2008, 12, 4),
+                datetime(2006, 12, 5): datetime(2006, 12, 4),
+                datetime(2006, 12, 30): datetime(2006, 12, 4),
+                datetime(2006, 12, 2): datetime(2006, 12, 1),
+                datetime(2007, 1, 1): datetime(2006, 12, 4),
+            },
+        ),
+        (
+            SemiMonthBegin(-2),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 1),
+                datetime(2008, 6, 30): datetime(2008, 6, 1),
+                datetime(2008, 6, 14): datetime(2008, 5, 15),
+                datetime(2008, 12, 31): datetime(2008, 12, 1),
+                datetime(2006, 12, 29): datetime(2006, 12, 1),
+                datetime(2006, 12, 15): datetime(2006, 11, 15),
+                datetime(2007, 1, 1): datetime(2006, 12, 1),
+            },
+        ),
+    ]
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_apply_index(self, case):
+        offset, cases = case
+        shift = DatetimeIndex(cases.keys())
+
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = offset + shift
+
+        exp = DatetimeIndex(cases.values())
+        tm.assert_index_equal(result, exp)
+
+    on_offset_cases = [
+        (datetime(2007, 12, 1), True),
+        (datetime(2007, 12, 15), True),
+        (datetime(2007, 12, 14), False),
+        (datetime(2007, 12, 31), False),
+        (datetime(2008, 2, 15), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        dt, expected = case
+        assert_is_on_offset(SemiMonthBegin(), dt, expected)
+
+    @pytest.mark.parametrize("klass", [Series, DatetimeIndex])
+    def test_vectorized_offset_addition(self, klass):
+        shift = klass(
+            [
+                Timestamp("2000-01-15 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-15", tz="US/Central"),
+            ],
+            name="a",
+        )
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = shift + SemiMonthBegin()
+            result2 = SemiMonthBegin() + shift
+
+        exp = klass(
+            [
+                Timestamp("2000-02-01 00:15:00", tz="US/Central"),
+                Timestamp("2000-03-01", tz="US/Central"),
+            ],
+            name="a",
+        )
+        tm.assert_equal(result, exp)
+        tm.assert_equal(result2, exp)
+
+        shift = klass(
+            [
+                Timestamp("2000-01-01 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-01", tz="US/Central"),
+            ],
+            name="a",
+        )
+        with tm.assert_produces_warning(None):
+            # GH#22535 check that we don't get a FutureWarning from adding
+            # an integer array to PeriodIndex
+            result = shift + SemiMonthBegin()
+            result2 = SemiMonthBegin() + shift
+
+        exp = klass(
+            [
+                Timestamp("2000-01-15 00:15:00", tz="US/Central"),
+                Timestamp("2000-02-15", tz="US/Central"),
+            ],
+            name="a",
+        )
+        tm.assert_equal(result, exp)
+        tm.assert_equal(result2, exp)
+
+
+class TestMonthBegin:
+    offset_cases = []
+    # NOTE: I'm not entirely happy with the logic here for Begin -ss
+    # see thread 'offset conventions' on the ML
+    offset_cases.append(
+        (
+            MonthBegin(),
+            {
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2008, 2, 1): datetime(2008, 3, 1),
+                datetime(2006, 12, 31): datetime(2007, 1, 1),
+                datetime(2006, 12, 1): datetime(2007, 1, 1),
+                datetime(2007, 1, 31): datetime(2007, 2, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthBegin(0),
+            {
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2006, 12, 3): datetime(2007, 1, 1),
+                datetime(2007, 1, 31): datetime(2007, 2, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthBegin(2),
+            {
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 1, 31): datetime(2008, 3, 1),
+                datetime(2006, 12, 31): datetime(2007, 2, 1),
+                datetime(2007, 12, 28): datetime(2008, 2, 1),
+                datetime(2007, 1, 1): datetime(2007, 3, 1),
+                datetime(2006, 11, 1): datetime(2007, 1, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthBegin(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 1),
+                datetime(2008, 5, 31): datetime(2008, 5, 1),
+                datetime(2008, 12, 31): datetime(2008, 12, 1),
+                datetime(2006, 12, 29): datetime(2006, 12, 1),
+                datetime(2006, 1, 2): datetime(2006, 1, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestMonthEnd:
+    def test_day_of_month(self):
+        dt = datetime(2007, 1, 1)
+        offset = MonthEnd()
+
+        result = dt + offset
+        assert result == Timestamp(2007, 1, 31)
+
+        result = result + offset
+        assert result == Timestamp(2007, 2, 28)
+
+    def test_normalize(self):
+        dt = datetime(2007, 1, 1, 3)
+
+        result = dt + MonthEnd(normalize=True)
+        expected = dt.replace(hour=0) + MonthEnd()
+        assert result == expected
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            MonthEnd(),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2007, 1, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 31),
+                datetime(2006, 12, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthEnd(0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2006, 12, 29): datetime(2006, 12, 31),
+                datetime(2006, 12, 31): datetime(2006, 12, 31),
+                datetime(2007, 1, 1): datetime(2007, 1, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthEnd(2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 1, 31): datetime(2008, 3, 31),
+                datetime(2006, 12, 29): datetime(2007, 1, 31),
+                datetime(2006, 12, 31): datetime(2007, 2, 28),
+                datetime(2007, 1, 1): datetime(2007, 2, 28),
+                datetime(2006, 11, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            MonthEnd(-1),
+            {
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+                datetime(2008, 6, 30): datetime(2008, 5, 31),
+                datetime(2008, 12, 31): datetime(2008, 11, 30),
+                datetime(2006, 12, 29): datetime(2006, 11, 30),
+                datetime(2006, 12, 30): datetime(2006, 11, 30),
+                datetime(2007, 1, 1): datetime(2006, 12, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (MonthEnd(), datetime(2007, 12, 31), True),
+        (MonthEnd(), datetime(2008, 1, 1), False),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_offsets.py

@@ -0,0 +1,1185 @@
+"""
+Tests of pandas.tseries.offsets
+"""
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    NaT,
+    Timedelta,
+    Timestamp,
+    conversion,
+    timezones,
+)
+import pandas._libs.tslibs.offsets as liboffsets
+from pandas._libs.tslibs.offsets import (
+    _get_offset,
+    _offset_map,
+    to_offset,
+)
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+from pandas.errors import PerformanceWarning
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import WeekDay
+
+from pandas.tseries import offsets
+from pandas.tseries.offsets import (
+    FY5253,
+    BDay,
+    BMonthEnd,
+    BusinessHour,
+    CustomBusinessDay,
+    CustomBusinessHour,
+    CustomBusinessMonthBegin,
+    CustomBusinessMonthEnd,
+    DateOffset,
+    Easter,
+    FY5253Quarter,
+    LastWeekOfMonth,
+    MonthBegin,
+    Nano,
+    Tick,
+    Week,
+    WeekOfMonth,
+)
+
+_ARITHMETIC_DATE_OFFSET = [
+    "years",
+    "months",
+    "weeks",
+    "days",
+    "hours",
+    "minutes",
+    "seconds",
+    "milliseconds",
+    "microseconds",
+]
+
+
+def _create_offset(klass, value=1, normalize=False):
+    # create instance from offset class
+    if klass is FY5253:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is FY5253Quarter:
+        klass = klass(
+            n=value,
+            startingMonth=1,
+            weekday=1,
+            qtr_with_extra_week=1,
+            variation="last",
+            normalize=normalize,
+        )
+    elif klass is LastWeekOfMonth:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is WeekOfMonth:
+        klass = klass(n=value, week=1, weekday=5, normalize=normalize)
+    elif klass is Week:
+        klass = klass(n=value, weekday=5, normalize=normalize)
+    elif klass is DateOffset:
+        klass = klass(days=value, normalize=normalize)
+    else:
+        klass = klass(value, normalize=normalize)
+    return klass
+
+
+@pytest.fixture(
+    params=[
+        getattr(offsets, o)
+        for o in offsets.__all__
+        if issubclass(getattr(offsets, o), liboffsets.MonthOffset)
+        and o != "MonthOffset"
+    ]
+)
+def month_classes(request):
+    """
+    Fixture for month based datetime offsets available for a time series.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        getattr(offsets, o) for o in offsets.__all__ if o not in ("Tick", "BaseOffset")
+    ]
+)
+def offset_types(request):
+    """
+    Fixture for all the datetime offsets available for a time series.
+    """
+    return request.param
+
+
+@pytest.fixture
+def dt():
+    return Timestamp(datetime(2008, 1, 2))
+
+
+@pytest.fixture
+def expecteds():
+    # executed value created by _create_offset
+    # are applied to 2011/01/01 09:00 (Saturday)
+    # used for .apply and .rollforward
+    return {
+        "Day": Timestamp("2011-01-02 09:00:00"),
+        "DateOffset": Timestamp("2011-01-02 09:00:00"),
+        "BusinessDay": Timestamp("2011-01-03 09:00:00"),
+        "CustomBusinessDay": Timestamp("2011-01-03 09:00:00"),
+        "CustomBusinessMonthEnd": Timestamp("2011-01-31 09:00:00"),
+        "CustomBusinessMonthBegin": Timestamp("2011-01-03 09:00:00"),
+        "MonthBegin": Timestamp("2011-02-01 09:00:00"),
+        "BusinessMonthBegin": Timestamp("2011-01-03 09:00:00"),
+        "MonthEnd": Timestamp("2011-01-31 09:00:00"),
+        "SemiMonthEnd": Timestamp("2011-01-15 09:00:00"),
+        "SemiMonthBegin": Timestamp("2011-01-15 09:00:00"),
+        "BusinessMonthEnd": Timestamp("2011-01-31 09:00:00"),
+        "YearBegin": Timestamp("2012-01-01 09:00:00"),
+        "BYearBegin": Timestamp("2011-01-03 09:00:00"),
+        "YearEnd": Timestamp("2011-12-31 09:00:00"),
+        "BYearEnd": Timestamp("2011-12-30 09:00:00"),
+        "QuarterBegin": Timestamp("2011-03-01 09:00:00"),
+        "BQuarterBegin": Timestamp("2011-03-01 09:00:00"),
+        "QuarterEnd": Timestamp("2011-03-31 09:00:00"),
+        "BQuarterEnd": Timestamp("2011-03-31 09:00:00"),
+        "BusinessHour": Timestamp("2011-01-03 10:00:00"),
+        "CustomBusinessHour": Timestamp("2011-01-03 10:00:00"),
+        "WeekOfMonth": Timestamp("2011-01-08 09:00:00"),
+        "LastWeekOfMonth": Timestamp("2011-01-29 09:00:00"),
+        "FY5253Quarter": Timestamp("2011-01-25 09:00:00"),
+        "FY5253": Timestamp("2011-01-25 09:00:00"),
+        "Week": Timestamp("2011-01-08 09:00:00"),
+        "Easter": Timestamp("2011-04-24 09:00:00"),
+        "Hour": Timestamp("2011-01-01 10:00:00"),
+        "Minute": Timestamp("2011-01-01 09:01:00"),
+        "Second": Timestamp("2011-01-01 09:00:01"),
+        "Milli": Timestamp("2011-01-01 09:00:00.001000"),
+        "Micro": Timestamp("2011-01-01 09:00:00.000001"),
+        "Nano": Timestamp("2011-01-01T09:00:00.000000001"),
+    }
+
+
+class TestCommon:
+    def test_immutable(self, offset_types):
+        # GH#21341 check that __setattr__ raises
+        offset = _create_offset(offset_types)
+        msg = "objects is not writable|DateOffset objects are immutable"
+        with pytest.raises(AttributeError, match=msg):
+            offset.normalize = True
+        with pytest.raises(AttributeError, match=msg):
+            offset.n = 91
+
+    def test_return_type(self, offset_types):
+        offset = _create_offset(offset_types)
+
+        # make sure that we are returning a Timestamp
+        result = Timestamp("20080101") + offset
+        assert isinstance(result, Timestamp)
+
+        # make sure that we are returning NaT
+        assert NaT + offset is NaT
+        assert offset + NaT is NaT
+
+        assert NaT - offset is NaT
+        assert (-offset)._apply(NaT) is NaT
+
+    def test_offset_n(self, offset_types):
+        offset = _create_offset(offset_types)
+        assert offset.n == 1
+
+        neg_offset = offset * -1
+        assert neg_offset.n == -1
+
+        mul_offset = offset * 3
+        assert mul_offset.n == 3
+
+    def test_offset_timedelta64_arg(self, offset_types):
+        # check that offset._validate_n raises TypeError on a timedelt64
+        #  object
+        off = _create_offset(offset_types)
+
+        td64 = np.timedelta64(4567, "s")
+        with pytest.raises(TypeError, match="argument must be an integer"):
+            type(off)(n=td64, **off.kwds)
+
+    def test_offset_mul_ndarray(self, offset_types):
+        off = _create_offset(offset_types)
+
+        expected = np.array([[off, off * 2], [off * 3, off * 4]])
+
+        result = np.array([[1, 2], [3, 4]]) * off
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = off * np.array([[1, 2], [3, 4]])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_offset_freqstr(self, offset_types):
+        offset = _create_offset(offset_types)
+
+        freqstr = offset.freqstr
+        if freqstr not in ("<Easter>", "<DateOffset: days=1>", "LWOM-SAT"):
+            code = _get_offset(freqstr)
+            assert offset.rule_code == code
+
+    def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=False):
+        if normalize and issubclass(offset, Tick):
+            # normalize=True disallowed for Tick subclasses GH#21427
+            return
+
+        offset_s = _create_offset(offset, normalize=normalize)
+        func = getattr(offset_s, funcname)
+
+        result = func(dt)
+        assert isinstance(result, Timestamp)
+        assert result == expected
+
+        result = func(Timestamp(dt))
+        assert isinstance(result, Timestamp)
+        assert result == expected
+
+        # see gh-14101
+        ts = Timestamp(dt) + Nano(5)
+        # test nanosecond is preserved
+        with tm.assert_produces_warning(None):
+            result = func(ts)
+
+        assert isinstance(result, Timestamp)
+        if normalize is False:
+            assert result == expected + Nano(5)
+        else:
+            assert result == expected
+
+        if isinstance(dt, np.datetime64):
+            # test tz when input is datetime or Timestamp
+            return
+
+        for tz in [
+            None,
+            "UTC",
+            "Asia/Tokyo",
+            "US/Eastern",
+            "dateutil/Asia/Tokyo",
+            "dateutil/US/Pacific",
+        ]:
+            expected_localize = expected.tz_localize(tz)
+            tz_obj = timezones.maybe_get_tz(tz)
+            dt_tz = conversion.localize_pydatetime(dt, tz_obj)
+
+            result = func(dt_tz)
+            assert isinstance(result, Timestamp)
+            assert result == expected_localize
+
+            result = func(Timestamp(dt, tz=tz))
+            assert isinstance(result, Timestamp)
+            assert result == expected_localize
+
+            # see gh-14101
+            ts = Timestamp(dt, tz=tz) + Nano(5)
+            # test nanosecond is preserved
+            with tm.assert_produces_warning(None):
+                result = func(ts)
+            assert isinstance(result, Timestamp)
+            if normalize is False:
+                assert result == expected_localize + Nano(5)
+            else:
+                assert result == expected_localize
+
+    def test_apply(self, offset_types, expecteds):
+        sdt = datetime(2011, 1, 1, 9, 0)
+        ndt = np.datetime64("2011-01-01 09:00")
+
+        expected = expecteds[offset_types.__name__]
+        expected_norm = Timestamp(expected.date())
+
+        for dt in [sdt, ndt]:
+            self._check_offsetfunc_works(offset_types, "_apply", dt, expected)
+
+            self._check_offsetfunc_works(
+                offset_types, "_apply", dt, expected_norm, normalize=True
+            )
+
+    def test_rollforward(self, offset_types, expecteds):
+        expecteds = expecteds.copy()
+
+        # result will not be changed if the target is on the offset
+        no_changes = [
+            "Day",
+            "MonthBegin",
+            "SemiMonthBegin",
+            "YearBegin",
+            "Week",
+            "Hour",
+            "Minute",
+            "Second",
+            "Milli",
+            "Micro",
+            "Nano",
+            "DateOffset",
+        ]
+        for n in no_changes:
+            expecteds[n] = Timestamp("2011/01/01 09:00")
+
+        expecteds["BusinessHour"] = Timestamp("2011-01-03 09:00:00")
+        expecteds["CustomBusinessHour"] = Timestamp("2011-01-03 09:00:00")
+
+        # but be changed when normalize=True
+        norm_expected = expecteds.copy()
+        for k in norm_expected:
+            norm_expected[k] = Timestamp(norm_expected[k].date())
+
+        normalized = {
+            "Day": Timestamp("2011-01-02 00:00:00"),
+            "DateOffset": Timestamp("2011-01-02 00:00:00"),
+            "MonthBegin": Timestamp("2011-02-01 00:00:00"),
+            "SemiMonthBegin": Timestamp("2011-01-15 00:00:00"),
+            "YearBegin": Timestamp("2012-01-01 00:00:00"),
+            "Week": Timestamp("2011-01-08 00:00:00"),
+            "Hour": Timestamp("2011-01-01 00:00:00"),
+            "Minute": Timestamp("2011-01-01 00:00:00"),
+            "Second": Timestamp("2011-01-01 00:00:00"),
+            "Milli": Timestamp("2011-01-01 00:00:00"),
+            "Micro": Timestamp("2011-01-01 00:00:00"),
+        }
+        norm_expected.update(normalized)
+
+        sdt = datetime(2011, 1, 1, 9, 0)
+        ndt = np.datetime64("2011-01-01 09:00")
+
+        for dt in [sdt, ndt]:
+            expected = expecteds[offset_types.__name__]
+            self._check_offsetfunc_works(offset_types, "rollforward", dt, expected)
+            expected = norm_expected[offset_types.__name__]
+            self._check_offsetfunc_works(
+                offset_types, "rollforward", dt, expected, normalize=True
+            )
+
+    def test_rollback(self, offset_types):
+        expecteds = {
+            "BusinessDay": Timestamp("2010-12-31 09:00:00"),
+            "CustomBusinessDay": Timestamp("2010-12-31 09:00:00"),
+            "CustomBusinessMonthEnd": Timestamp("2010-12-31 09:00:00"),
+            "CustomBusinessMonthBegin": Timestamp("2010-12-01 09:00:00"),
+            "BusinessMonthBegin": Timestamp("2010-12-01 09:00:00"),
+            "MonthEnd": Timestamp("2010-12-31 09:00:00"),
+            "SemiMonthEnd": Timestamp("2010-12-31 09:00:00"),
+            "BusinessMonthEnd": Timestamp("2010-12-31 09:00:00"),
+            "BYearBegin": Timestamp("2010-01-01 09:00:00"),
+            "YearEnd": Timestamp("2010-12-31 09:00:00"),
+            "BYearEnd": Timestamp("2010-12-31 09:00:00"),
+            "QuarterBegin": Timestamp("2010-12-01 09:00:00"),
+            "BQuarterBegin": Timestamp("2010-12-01 09:00:00"),
+            "QuarterEnd": Timestamp("2010-12-31 09:00:00"),
+            "BQuarterEnd": Timestamp("2010-12-31 09:00:00"),
+            "BusinessHour": Timestamp("2010-12-31 17:00:00"),
+            "CustomBusinessHour": Timestamp("2010-12-31 17:00:00"),
+            "WeekOfMonth": Timestamp("2010-12-11 09:00:00"),
+            "LastWeekOfMonth": Timestamp("2010-12-25 09:00:00"),
+            "FY5253Quarter": Timestamp("2010-10-26 09:00:00"),
+            "FY5253": Timestamp("2010-01-26 09:00:00"),
+            "Easter": Timestamp("2010-04-04 09:00:00"),
+        }
+
+        # result will not be changed if the target is on the offset
+        for n in [
+            "Day",
+            "MonthBegin",
+            "SemiMonthBegin",
+            "YearBegin",
+            "Week",
+            "Hour",
+            "Minute",
+            "Second",
+            "Milli",
+            "Micro",
+            "Nano",
+            "DateOffset",
+        ]:
+            expecteds[n] = Timestamp("2011/01/01 09:00")
+
+        # but be changed when normalize=True
+        norm_expected = expecteds.copy()
+        for k in norm_expected:
+            norm_expected[k] = Timestamp(norm_expected[k].date())
+
+        normalized = {
+            "Day": Timestamp("2010-12-31 00:00:00"),
+            "DateOffset": Timestamp("2010-12-31 00:00:00"),
+            "MonthBegin": Timestamp("2010-12-01 00:00:00"),
+            "SemiMonthBegin": Timestamp("2010-12-15 00:00:00"),
+            "YearBegin": Timestamp("2010-01-01 00:00:00"),
+            "Week": Timestamp("2010-12-25 00:00:00"),
+            "Hour": Timestamp("2011-01-01 00:00:00"),
+            "Minute": Timestamp("2011-01-01 00:00:00"),
+            "Second": Timestamp("2011-01-01 00:00:00"),
+            "Milli": Timestamp("2011-01-01 00:00:00"),
+            "Micro": Timestamp("2011-01-01 00:00:00"),
+        }
+        norm_expected.update(normalized)
+
+        sdt = datetime(2011, 1, 1, 9, 0)
+        ndt = np.datetime64("2011-01-01 09:00")
+
+        for dt in [sdt, ndt]:
+            expected = expecteds[offset_types.__name__]
+            self._check_offsetfunc_works(offset_types, "rollback", dt, expected)
+
+            expected = norm_expected[offset_types.__name__]
+            self._check_offsetfunc_works(
+                offset_types, "rollback", dt, expected, normalize=True
+            )
+
+    def test_is_on_offset(self, offset_types, expecteds):
+        dt = expecteds[offset_types.__name__]
+        offset_s = _create_offset(offset_types)
+        assert offset_s.is_on_offset(dt)
+
+        # when normalize=True, is_on_offset checks time is 00:00:00
+        if issubclass(offset_types, Tick):
+            # normalize=True disallowed for Tick subclasses GH#21427
+            return
+        offset_n = _create_offset(offset_types, normalize=True)
+        assert not offset_n.is_on_offset(dt)
+
+        if offset_types in (BusinessHour, CustomBusinessHour):
+            # In default BusinessHour (9:00-17:00), normalized time
+            # cannot be in business hour range
+            return
+        date = datetime(dt.year, dt.month, dt.day)
+        assert offset_n.is_on_offset(date)
+
+    def test_add(self, offset_types, tz_naive_fixture, expecteds):
+        tz = tz_naive_fixture
+        dt = datetime(2011, 1, 1, 9, 0)
+
+        offset_s = _create_offset(offset_types)
+        expected = expecteds[offset_types.__name__]
+
+        result_dt = dt + offset_s
+        result_ts = Timestamp(dt) + offset_s
+        for result in [result_dt, result_ts]:
+            assert isinstance(result, Timestamp)
+            assert result == expected
+
+        expected_localize = expected.tz_localize(tz)
+        result = Timestamp(dt, tz=tz) + offset_s
+        assert isinstance(result, Timestamp)
+        assert result == expected_localize
+
+        # normalize=True, disallowed for Tick subclasses GH#21427
+        if issubclass(offset_types, Tick):
+            return
+        offset_s = _create_offset(offset_types, normalize=True)
+        expected = Timestamp(expected.date())
+
+        result_dt = dt + offset_s
+        result_ts = Timestamp(dt) + offset_s
+        for result in [result_dt, result_ts]:
+            assert isinstance(result, Timestamp)
+            assert result == expected
+
+        expected_localize = expected.tz_localize(tz)
+        result = Timestamp(dt, tz=tz) + offset_s
+        assert isinstance(result, Timestamp)
+        assert result == expected_localize
+
+    def test_add_empty_datetimeindex(self, offset_types, tz_naive_fixture):
+        # GH#12724, GH#30336
+        offset_s = _create_offset(offset_types)
+
+        dti = DatetimeIndex([], tz=tz_naive_fixture).as_unit("ns")
+
+        warn = None
+        if isinstance(
+            offset_s,
+            (
+                Easter,
+                WeekOfMonth,
+                LastWeekOfMonth,
+                CustomBusinessDay,
+                BusinessHour,
+                CustomBusinessHour,
+                CustomBusinessMonthBegin,
+                CustomBusinessMonthEnd,
+                FY5253,
+                FY5253Quarter,
+            ),
+        ):
+            # We don't have an optimized apply_index
+            warn = PerformanceWarning
+
+        # stacklevel checking is slow, and we have ~800 of variants of this
+        #  test, so let's only check the stacklevel in a subset of them
+        check_stacklevel = tz_naive_fixture is None
+        with tm.assert_produces_warning(warn, check_stacklevel=check_stacklevel):
+            result = dti + offset_s
+        tm.assert_index_equal(result, dti)
+        with tm.assert_produces_warning(warn, check_stacklevel=check_stacklevel):
+            result = offset_s + dti
+        tm.assert_index_equal(result, dti)
+
+        dta = dti._data
+        with tm.assert_produces_warning(warn, check_stacklevel=check_stacklevel):
+            result = dta + offset_s
+        tm.assert_equal(result, dta)
+        with tm.assert_produces_warning(warn, check_stacklevel=check_stacklevel):
+            result = offset_s + dta
+        tm.assert_equal(result, dta)
+
+    def test_pickle_roundtrip(self, offset_types):
+        off = _create_offset(offset_types)
+        res = tm.round_trip_pickle(off)
+        assert off == res
+        if type(off) is not DateOffset:
+            for attr in off._attributes:
+                if attr == "calendar":
+                    # np.busdaycalendar __eq__ will return False;
+                    #  we check holidays and weekmask attrs so are OK
+                    continue
+                # Make sure nothings got lost from _params (which __eq__) is based on
+                assert getattr(off, attr) == getattr(res, attr)
+
+    def test_pickle_dateoffset_odd_inputs(self):
+        # GH#34511
+        off = DateOffset(months=12)
+        res = tm.round_trip_pickle(off)
+        assert off == res
+
+        base_dt = datetime(2020, 1, 1)
+        assert base_dt + off == base_dt + res
+
+    def test_offsets_hashable(self, offset_types):
+        # GH: 37267
+        off = _create_offset(offset_types)
+        assert hash(off) is not None
+
+    # TODO: belongs in arithmetic tests?
+    @pytest.mark.filterwarnings(
+        "ignore:Non-vectorized DateOffset being applied to Series or DatetimeIndex"
+    )
+    @pytest.mark.parametrize("unit", ["s", "ms", "us"])
+    def test_add_dt64_ndarray_non_nano(self, offset_types, unit):
+        # check that the result with non-nano matches nano
+        off = _create_offset(offset_types)
+
+        dti = date_range("2016-01-01", periods=35, freq="D", unit=unit)
+
+        result = (dti + off)._with_freq(None)
+
+        exp_unit = unit
+        if isinstance(off, Tick) and off._creso > dti._data._creso:
+            # cast to higher reso like we would with Timedelta scalar
+            exp_unit = Timedelta(off).unit
+        # TODO(GH#55564): as_unit will be unnecessary
+        expected = DatetimeIndex([x + off for x in dti]).as_unit(exp_unit)
+
+        tm.assert_index_equal(result, expected)
+
+
+class TestDateOffset:
+    def setup_method(self):
+        _offset_map.clear()
+
+    def test_repr(self):
+        repr(DateOffset())
+        repr(DateOffset(2))
+        repr(2 * DateOffset())
+        repr(2 * DateOffset(months=2))
+
+    def test_mul(self):
+        assert DateOffset(2) == 2 * DateOffset(1)
+        assert DateOffset(2) == DateOffset(1) * 2
+
+    @pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+    def test_constructor(self, kwd, request):
+        if kwd == "millisecond":
+            request.applymarker(
+                pytest.mark.xfail(
+                    raises=NotImplementedError,
+                    reason="Constructing DateOffset object with `millisecond` is not "
+                    "yet supported.",
+                )
+            )
+        offset = DateOffset(**{kwd: 2})
+        assert offset.kwds == {kwd: 2}
+        assert getattr(offset, kwd) == 2
+
+    def test_default_constructor(self, dt):
+        assert (dt + DateOffset(2)) == datetime(2008, 1, 4)
+
+    def test_is_anchored(self):
+        msg = "DateOffset.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert not DateOffset(2).is_anchored()
+            assert DateOffset(1).is_anchored()
+
+    def test_copy(self):
+        assert DateOffset(months=2).copy() == DateOffset(months=2)
+        assert DateOffset(milliseconds=1).copy() == DateOffset(milliseconds=1)
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            [
+                "2009-01-02",
+                "2008-02-02",
+                "2008-01-09",
+                "2008-01-03",
+                "2008-01-02 01:00:00",
+                "2008-01-02 00:01:00",
+                "2008-01-02 00:00:01",
+                "2008-01-02 00:00:00.001000000",
+                "2008-01-02 00:00:00.000001000",
+            ],
+        ),
+    )
+    def test_add(self, arithmatic_offset_type, expected, dt):
+        assert DateOffset(**{arithmatic_offset_type: 1}) + dt == Timestamp(expected)
+        assert dt + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            [
+                "2007-01-02",
+                "2007-12-02",
+                "2007-12-26",
+                "2008-01-01",
+                "2008-01-01 23:00:00",
+                "2008-01-01 23:59:00",
+                "2008-01-01 23:59:59",
+                "2008-01-01 23:59:59.999000000",
+                "2008-01-01 23:59:59.999999000",
+            ],
+        ),
+    )
+    def test_sub(self, arithmatic_offset_type, expected, dt):
+        assert dt - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+        with pytest.raises(TypeError, match="Cannot subtract datetime from offset"):
+            DateOffset(**{arithmatic_offset_type: 1}) - dt
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, n, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            range(1, 10),
+            [
+                "2009-01-02",
+                "2008-03-02",
+                "2008-01-23",
+                "2008-01-06",
+                "2008-01-02 05:00:00",
+                "2008-01-02 00:06:00",
+                "2008-01-02 00:00:07",
+                "2008-01-02 00:00:00.008000000",
+                "2008-01-02 00:00:00.000009000",
+            ],
+        ),
+    )
+    def test_mul_add(self, arithmatic_offset_type, n, expected, dt):
+        assert DateOffset(**{arithmatic_offset_type: 1}) * n + dt == Timestamp(expected)
+        assert n * DateOffset(**{arithmatic_offset_type: 1}) + dt == Timestamp(expected)
+        assert dt + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected)
+        assert dt + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+
+    @pytest.mark.parametrize(
+        "arithmatic_offset_type, n, expected",
+        zip(
+            _ARITHMETIC_DATE_OFFSET,
+            range(1, 10),
+            [
+                "2007-01-02",
+                "2007-11-02",
+                "2007-12-12",
+                "2007-12-29",
+                "2008-01-01 19:00:00",
+                "2008-01-01 23:54:00",
+                "2008-01-01 23:59:53",
+                "2008-01-01 23:59:59.992000000",
+                "2008-01-01 23:59:59.999991000",
+            ],
+        ),
+    )
+    def test_mul_sub(self, arithmatic_offset_type, n, expected, dt):
+        assert dt - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected)
+        assert dt - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected)
+
+    def test_leap_year(self):
+        d = datetime(2008, 1, 31)
+        assert (d + DateOffset(months=1)) == datetime(2008, 2, 29)
+
+    def test_eq(self):
+        offset1 = DateOffset(days=1)
+        offset2 = DateOffset(days=365)
+
+        assert offset1 != offset2
+
+        assert DateOffset(milliseconds=3) != DateOffset(milliseconds=7)
+
+    @pytest.mark.parametrize(
+        "offset_kwargs, expected_arg",
+        [
+            ({"microseconds": 1, "milliseconds": 1}, "2022-01-01 00:00:00.001001"),
+            ({"seconds": 1, "milliseconds": 1}, "2022-01-01 00:00:01.001"),
+            ({"minutes": 1, "milliseconds": 1}, "2022-01-01 00:01:00.001"),
+            ({"hours": 1, "milliseconds": 1}, "2022-01-01 01:00:00.001"),
+            ({"days": 1, "milliseconds": 1}, "2022-01-02 00:00:00.001"),
+            ({"weeks": 1, "milliseconds": 1}, "2022-01-08 00:00:00.001"),
+            ({"months": 1, "milliseconds": 1}, "2022-02-01 00:00:00.001"),
+            ({"years": 1, "milliseconds": 1}, "2023-01-01 00:00:00.001"),
+        ],
+    )
+    def test_milliseconds_combination(self, offset_kwargs, expected_arg):
+        # GH 49897
+        offset = DateOffset(**offset_kwargs)
+        ts = Timestamp("2022-01-01")
+        result = ts + offset
+        expected = Timestamp(expected_arg)
+
+        assert result == expected
+
+    def test_offset_invalid_arguments(self):
+        msg = "^Invalid argument/s or bad combination of arguments"
+        with pytest.raises(ValueError, match=msg):
+            DateOffset(picoseconds=1)
+
+
+class TestOffsetNames:
+    def test_get_offset_name(self):
+        assert BDay().freqstr == "B"
+        assert BDay(2).freqstr == "2B"
+        assert BMonthEnd().freqstr == "BME"
+        assert Week(weekday=0).freqstr == "W-MON"
+        assert Week(weekday=1).freqstr == "W-TUE"
+        assert Week(weekday=2).freqstr == "W-WED"
+        assert Week(weekday=3).freqstr == "W-THU"
+        assert Week(weekday=4).freqstr == "W-FRI"
+
+        assert LastWeekOfMonth(weekday=WeekDay.SUN).freqstr == "LWOM-SUN"
+
+
+def test_get_offset():
+    with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+        _get_offset("gibberish")
+    with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+        _get_offset("QS-JAN-B")
+
+    pairs = [
+        ("B", BDay()),
+        ("b", BDay()),
+        ("bme", BMonthEnd()),
+        ("Bme", BMonthEnd()),
+        ("W-MON", Week(weekday=0)),
+        ("W-TUE", Week(weekday=1)),
+        ("W-WED", Week(weekday=2)),
+        ("W-THU", Week(weekday=3)),
+        ("W-FRI", Week(weekday=4)),
+    ]
+
+    for name, expected in pairs:
+        offset = _get_offset(name)
+        assert offset == expected, (
+            f"Expected {repr(name)} to yield {repr(expected)} "
+            f"(actual: {repr(offset)})"
+        )
+
+
+def test_get_offset_legacy():
+    pairs = [("w@Sat", Week(weekday=5))]
+    for name, expected in pairs:
+        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+            _get_offset(name)
+
+
+class TestOffsetAliases:
+    def setup_method(self):
+        _offset_map.clear()
+
+    def test_alias_equality(self):
+        for k, v in _offset_map.items():
+            if v is None:
+                continue
+            assert k == v.copy()
+
+    def test_rule_code(self):
+        lst = ["ME", "MS", "BME", "BMS", "D", "B", "h", "min", "s", "ms", "us"]
+        for k in lst:
+            assert k == _get_offset(k).rule_code
+            # should be cached - this is kind of an internals test...
+            assert k in _offset_map
+            assert k == (_get_offset(k) * 3).rule_code
+
+        suffix_lst = ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"]
+        base = "W"
+        for v in suffix_lst:
+            alias = "-".join([base, v])
+            assert alias == _get_offset(alias).rule_code
+            assert alias == (_get_offset(alias) * 5).rule_code
+
+        suffix_lst = [
+            "JAN",
+            "FEB",
+            "MAR",
+            "APR",
+            "MAY",
+            "JUN",
+            "JUL",
+            "AUG",
+            "SEP",
+            "OCT",
+            "NOV",
+            "DEC",
+        ]
+        base_lst = ["YE", "YS", "BYE", "BYS", "QE", "QS", "BQE", "BQS"]
+        for base in base_lst:
+            for v in suffix_lst:
+                alias = "-".join([base, v])
+                assert alias == _get_offset(alias).rule_code
+                assert alias == (_get_offset(alias) * 5).rule_code
+
+
+def test_freq_offsets():
+    off = BDay(1, offset=timedelta(0, 1800))
+    assert off.freqstr == "B+30Min"
+
+    off = BDay(1, offset=timedelta(0, -1800))
+    assert off.freqstr == "B-30Min"
+
+
+class TestReprNames:
+    def test_str_for_named_is_name(self):
+        # look at all the amazing combinations!
+        month_prefixes = ["YE", "YS", "BYE", "BYS", "QE", "BQE", "BQS", "QS"]
+        names = [
+            prefix + "-" + month
+            for prefix in month_prefixes
+            for month in [
+                "JAN",
+                "FEB",
+                "MAR",
+                "APR",
+                "MAY",
+                "JUN",
+                "JUL",
+                "AUG",
+                "SEP",
+                "OCT",
+                "NOV",
+                "DEC",
+            ]
+        ]
+        days = ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"]
+        names += ["W-" + day for day in days]
+        names += ["WOM-" + week + day for week in ("1", "2", "3", "4") for day in days]
+        _offset_map.clear()
+        for name in names:
+            offset = _get_offset(name)
+            assert offset.freqstr == name
+
+
+# ---------------------------------------------------------------------
+
+
+def test_valid_default_arguments(offset_types):
+    # GH#19142 check that the calling the constructors without passing
+    # any keyword arguments produce valid offsets
+    cls = offset_types
+    cls()
+
+
+@pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+def test_valid_month_attributes(kwd, month_classes):
+    # GH#18226
+    cls = month_classes
+    # check that we cannot create e.g. MonthEnd(weeks=3)
+    msg = rf"__init__\(\) got an unexpected keyword argument '{kwd}'"
+    with pytest.raises(TypeError, match=msg):
+        cls(**{kwd: 3})
+
+
+def test_month_offset_name(month_classes):
+    # GH#33757 off.name with n != 1 should not raise AttributeError
+    obj = month_classes(1)
+    obj2 = month_classes(2)
+    assert obj2.name == obj.name
+
+
+@pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+def test_valid_relativedelta_kwargs(kwd, request):
+    if kwd == "millisecond":
+        request.applymarker(
+            pytest.mark.xfail(
+                raises=NotImplementedError,
+                reason="Constructing DateOffset object with `millisecond` is not "
+                "yet supported.",
+            )
+        )
+    # Check that all the arguments specified in liboffsets._relativedelta_kwds
+    # are in fact valid relativedelta keyword args
+    DateOffset(**{kwd: 1})
+
+
+@pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+def test_valid_tick_attributes(kwd, tick_classes):
+    # GH#18226
+    cls = tick_classes
+    # check that we cannot create e.g. Hour(weeks=3)
+    msg = rf"__init__\(\) got an unexpected keyword argument '{kwd}'"
+    with pytest.raises(TypeError, match=msg):
+        cls(**{kwd: 3})
+
+
+def test_validate_n_error():
+    with pytest.raises(TypeError, match="argument must be an integer"):
+        DateOffset(n="Doh!")
+
+    with pytest.raises(TypeError, match="argument must be an integer"):
+        MonthBegin(n=timedelta(1))
+
+    with pytest.raises(TypeError, match="argument must be an integer"):
+        BDay(n=np.array([1, 2], dtype=np.int64))
+
+
+def test_require_integers(offset_types):
+    cls = offset_types
+    with pytest.raises(ValueError, match="argument must be an integer"):
+        cls(n=1.5)
+
+
+def test_tick_normalize_raises(tick_classes):
+    # check that trying to create a Tick object with normalize=True raises
+    # GH#21427
+    cls = tick_classes
+    msg = "Tick offset with `normalize=True` are not allowed."
+    with pytest.raises(ValueError, match=msg):
+        cls(n=3, normalize=True)
+
+
+@pytest.mark.parametrize(
+    "offset_kwargs, expected_arg",
+    [
+        ({"nanoseconds": 1}, "1970-01-01 00:00:00.000000001"),
+        ({"nanoseconds": 5}, "1970-01-01 00:00:00.000000005"),
+        ({"nanoseconds": -1}, "1969-12-31 23:59:59.999999999"),
+        ({"microseconds": 1}, "1970-01-01 00:00:00.000001"),
+        ({"microseconds": -1}, "1969-12-31 23:59:59.999999"),
+        ({"seconds": 1}, "1970-01-01 00:00:01"),
+        ({"seconds": -1}, "1969-12-31 23:59:59"),
+        ({"minutes": 1}, "1970-01-01 00:01:00"),
+        ({"minutes": -1}, "1969-12-31 23:59:00"),
+        ({"hours": 1}, "1970-01-01 01:00:00"),
+        ({"hours": -1}, "1969-12-31 23:00:00"),
+        ({"days": 1}, "1970-01-02 00:00:00"),
+        ({"days": -1}, "1969-12-31 00:00:00"),
+        ({"weeks": 1}, "1970-01-08 00:00:00"),
+        ({"weeks": -1}, "1969-12-25 00:00:00"),
+        ({"months": 1}, "1970-02-01 00:00:00"),
+        ({"months": -1}, "1969-12-01 00:00:00"),
+        ({"years": 1}, "1971-01-01 00:00:00"),
+        ({"years": -1}, "1969-01-01 00:00:00"),
+    ],
+)
+def test_dateoffset_add_sub(offset_kwargs, expected_arg):
+    offset = DateOffset(**offset_kwargs)
+    ts = Timestamp(0)
+    result = ts + offset
+    expected = Timestamp(expected_arg)
+    assert result == expected
+    result -= offset
+    assert result == ts
+    result = offset + ts
+    assert result == expected
+
+
+def test_dateoffset_add_sub_timestamp_with_nano():
+    offset = DateOffset(minutes=2, nanoseconds=9)
+    ts = Timestamp(4)
+    result = ts + offset
+    expected = Timestamp("1970-01-01 00:02:00.000000013")
+    assert result == expected
+    result -= offset
+    assert result == ts
+    result = offset + ts
+    assert result == expected
+
+    offset2 = DateOffset(minutes=2, nanoseconds=9, hour=1)
+    assert offset2._use_relativedelta
+    with tm.assert_produces_warning(None):
+        # no warning about Discarding nonzero nanoseconds
+        result2 = ts + offset2
+    expected2 = Timestamp("1970-01-01 01:02:00.000000013")
+    assert result2 == expected2
+
+
+@pytest.mark.parametrize(
+    "attribute",
+    [
+        "hours",
+        "days",
+        "weeks",
+        "months",
+        "years",
+    ],
+)
+def test_dateoffset_immutable(attribute):
+    offset = DateOffset(**{attribute: 0})
+    msg = "DateOffset objects are immutable"
+    with pytest.raises(AttributeError, match=msg):
+        setattr(offset, attribute, 5)
+
+
+def test_dateoffset_misc():
+    oset = offsets.DateOffset(months=2, days=4)
+    # it works
+    oset.freqstr
+
+    assert not offsets.DateOffset(months=2) == 2
+
+
+@pytest.mark.parametrize("n", [-1, 1, 3])
+def test_construct_int_arg_no_kwargs_assumed_days(n):
+    # GH 45890, 45643
+    offset = DateOffset(n)
+    assert offset._offset == timedelta(1)
+    result = Timestamp(2022, 1, 2) + offset
+    expected = Timestamp(2022, 1, 2 + n)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "offset, expected",
+    [
+        (
+            DateOffset(minutes=7, nanoseconds=18),
+            Timestamp("2022-01-01 00:07:00.000000018"),
+        ),
+        (DateOffset(nanoseconds=3), Timestamp("2022-01-01 00:00:00.000000003")),
+    ],
+)
+def test_dateoffset_add_sub_timestamp_series_with_nano(offset, expected):
+    # GH 47856
+    start_time = Timestamp("2022-01-01")
+    teststamp = start_time
+    testseries = Series([start_time])
+    testseries = testseries + offset
+    assert testseries[0] == expected
+    testseries -= offset
+    assert testseries[0] == teststamp
+    testseries = offset + testseries
+    assert testseries[0] == expected
+
+
+@pytest.mark.parametrize(
+    "n_months, scaling_factor, start_timestamp, expected_timestamp",
+    [
+        (1, 2, "2020-01-30", "2020-03-30"),
+        (2, 1, "2020-01-30", "2020-03-30"),
+        (1, 0, "2020-01-30", "2020-01-30"),
+        (2, 0, "2020-01-30", "2020-01-30"),
+        (1, -1, "2020-01-30", "2019-12-30"),
+        (2, -1, "2020-01-30", "2019-11-30"),
+    ],
+)
+def test_offset_multiplication(
+    n_months, scaling_factor, start_timestamp, expected_timestamp
+):
+    # GH 47953
+    mo1 = DateOffset(months=n_months)
+
+    startscalar = Timestamp(start_timestamp)
+    startarray = Series([startscalar])
+
+    resultscalar = startscalar + (mo1 * scaling_factor)
+    resultarray = startarray + (mo1 * scaling_factor)
+
+    expectedscalar = Timestamp(expected_timestamp)
+    expectedarray = Series([expectedscalar])
+    assert resultscalar == expectedscalar
+
+    tm.assert_series_equal(resultarray, expectedarray)
+
+
+def test_dateoffset_operations_on_dataframes():
+    # GH 47953
+    df = DataFrame({"T": [Timestamp("2019-04-30")], "D": [DateOffset(months=1)]})
+    frameresult1 = df["T"] + 26 * df["D"]
+    df2 = DataFrame(
+        {
+            "T": [Timestamp("2019-04-30"), Timestamp("2019-04-30")],
+            "D": [DateOffset(months=1), DateOffset(months=1)],
+        }
+    )
+    expecteddate = Timestamp("2021-06-30")
+    with tm.assert_produces_warning(PerformanceWarning):
+        frameresult2 = df2["T"] + 26 * df2["D"]
+
+    assert frameresult1[0] == expecteddate
+    assert frameresult2[0] == expecteddate
+
+
+def test_is_yqm_start_end():
+    freq_m = to_offset("ME")
+    bm = to_offset("BME")
+    qfeb = to_offset("QE-FEB")
+    qsfeb = to_offset("QS-FEB")
+    bq = to_offset("BQE")
+    bqs_apr = to_offset("BQS-APR")
+    as_nov = to_offset("YS-NOV")
+
+    tests = [
+        (freq_m.is_month_start(Timestamp("2013-06-01")), 1),
+        (bm.is_month_start(Timestamp("2013-06-01")), 0),
+        (freq_m.is_month_start(Timestamp("2013-06-03")), 0),
+        (bm.is_month_start(Timestamp("2013-06-03")), 1),
+        (qfeb.is_month_end(Timestamp("2013-02-28")), 1),
+        (qfeb.is_quarter_end(Timestamp("2013-02-28")), 1),
+        (qfeb.is_year_end(Timestamp("2013-02-28")), 1),
+        (qfeb.is_month_start(Timestamp("2013-03-01")), 1),
+        (qfeb.is_quarter_start(Timestamp("2013-03-01")), 1),
+        (qfeb.is_year_start(Timestamp("2013-03-01")), 1),
+        (qsfeb.is_month_end(Timestamp("2013-03-31")), 1),
+        (qsfeb.is_quarter_end(Timestamp("2013-03-31")), 0),
+        (qsfeb.is_year_end(Timestamp("2013-03-31")), 0),
+        (qsfeb.is_month_start(Timestamp("2013-02-01")), 1),
+        (qsfeb.is_quarter_start(Timestamp("2013-02-01")), 1),
+        (qsfeb.is_year_start(Timestamp("2013-02-01")), 1),
+        (bq.is_month_end(Timestamp("2013-06-30")), 0),
+        (bq.is_quarter_end(Timestamp("2013-06-30")), 0),
+        (bq.is_year_end(Timestamp("2013-06-30")), 0),
+        (bq.is_month_end(Timestamp("2013-06-28")), 1),
+        (bq.is_quarter_end(Timestamp("2013-06-28")), 1),
+        (bq.is_year_end(Timestamp("2013-06-28")), 0),
+        (bqs_apr.is_month_end(Timestamp("2013-06-30")), 0),
+        (bqs_apr.is_quarter_end(Timestamp("2013-06-30")), 0),
+        (bqs_apr.is_year_end(Timestamp("2013-06-30")), 0),
+        (bqs_apr.is_month_end(Timestamp("2013-06-28")), 1),
+        (bqs_apr.is_quarter_end(Timestamp("2013-06-28")), 1),
+        (bqs_apr.is_year_end(Timestamp("2013-03-29")), 1),
+        (as_nov.is_year_start(Timestamp("2013-11-01")), 1),
+        (as_nov.is_year_end(Timestamp("2013-10-31")), 1),
+        (Timestamp("2012-02-01").days_in_month, 29),
+        (Timestamp("2013-02-01").days_in_month, 28),
+    ]
+
+    for ts, value in tests:
+        assert ts == value

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_offsets_properties.py

@@ -0,0 +1,60 @@
+"""
+Behavioral based tests for offsets and date_range.
+
+This file is adapted from https://github.com/pandas-dev/pandas/pull/18761 -
+which was more ambitious but less idiomatic in its use of Hypothesis.
+
+You may wish to consult the previous version for inspiration on further
+tests, or when trying to pin down the bugs exposed by the tests below.
+"""
+from hypothesis import (
+    assume,
+    given,
+)
+import pytest
+import pytz
+
+import pandas as pd
+from pandas._testing._hypothesis import (
+    DATETIME_JAN_1_1900_OPTIONAL_TZ,
+    YQM_OFFSET,
+)
+
+# ----------------------------------------------------------------
+# Offset-specific behaviour tests
+
+
+@pytest.mark.arm_slow
+@given(DATETIME_JAN_1_1900_OPTIONAL_TZ, YQM_OFFSET)
+def test_on_offset_implementations(dt, offset):
+    assume(not offset.normalize)
+    # check that the class-specific implementations of is_on_offset match
+    # the general case definition:
+    #   (dt + offset) - offset == dt
+    try:
+        compare = (dt + offset) - offset
+    except (pytz.NonExistentTimeError, pytz.AmbiguousTimeError):
+        # When dt + offset does not exist or is DST-ambiguous, assume(False) to
+        # indicate to hypothesis that this is not a valid test case
+        # DST-ambiguous example (GH41906):
+        # dt = datetime.datetime(1900, 1, 1, tzinfo=pytz.timezone('Africa/Kinshasa'))
+        # offset = MonthBegin(66)
+        assume(False)
+
+    assert offset.is_on_offset(dt) == (compare == dt)
+
+
+@given(YQM_OFFSET)
+def test_shift_across_dst(offset):
+    # GH#18319 check that 1) timezone is correctly normalized and
+    # 2) that hour is not incorrectly changed by this normalization
+    assume(not offset.normalize)
+
+    # Note that dti includes a transition across DST boundary
+    dti = pd.date_range(
+        start="2017-10-30 12:00:00", end="2017-11-06", freq="D", tz="US/Eastern"
+    )
+    assert (dti.hour == 12).all()  # we haven't screwed up yet
+
+    res = dti + offset
+    assert (res.hour == 12).all()

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_quarter.py

@@ -0,0 +1,303 @@
+"""
+Tests for the following offsets:
+- QuarterBegin
+- QuarterEnd
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+import pandas._testing as tm
+from pandas.tests.tseries.offsets.common import (
+    assert_is_on_offset,
+    assert_offset_equal,
+)
+
+from pandas.tseries.offsets import (
+    QuarterBegin,
+    QuarterEnd,
+)
+
+
+@pytest.mark.parametrize("klass", (QuarterBegin, QuarterEnd))
+def test_quarterly_dont_normalize(klass):
+    date = datetime(2012, 3, 31, 5, 30)
+    result = date + klass()
+    assert result.time() == date.time()
+
+
+@pytest.mark.parametrize("offset", [QuarterBegin(), QuarterEnd()])
+@pytest.mark.parametrize(
+    "date",
+    [
+        datetime(2016, m, d)
+        for m in [10, 11, 12]
+        for d in [1, 2, 3, 28, 29, 30, 31]
+        if not (m == 11 and d == 31)
+    ],
+)
+def test_on_offset(offset, date):
+    res = offset.is_on_offset(date)
+    slow_version = date == (date + offset) - offset
+    assert res == slow_version
+
+
+class TestQuarterBegin:
+    def test_repr(self):
+        expected = "<QuarterBegin: startingMonth=3>"
+        assert repr(QuarterBegin()) == expected
+        expected = "<QuarterBegin: startingMonth=3>"
+        assert repr(QuarterBegin(startingMonth=3)) == expected
+        expected = "<QuarterBegin: startingMonth=1>"
+        assert repr(QuarterBegin(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "QuarterBegin.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert QuarterBegin(startingMonth=1).is_anchored()
+            assert QuarterBegin().is_anchored()
+            assert not QuarterBegin(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = QuarterBegin(n=-1, startingMonth=1)
+        assert datetime(2010, 2, 1) + offset == datetime(2010, 1, 1)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1),
+            {
+                datetime(2007, 12, 1): datetime(2008, 1, 1),
+                datetime(2008, 1, 1): datetime(2008, 4, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2008, 3, 31): datetime(2008, 4, 1),
+                datetime(2008, 4, 15): datetime(2008, 7, 1),
+                datetime(2008, 4, 1): datetime(2008, 7, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 1),
+                datetime(2008, 1, 31): datetime(2008, 2, 1),
+                datetime(2008, 1, 15): datetime(2008, 2, 1),
+                datetime(2008, 2, 29): datetime(2008, 5, 1),
+                datetime(2008, 3, 15): datetime(2008, 5, 1),
+                datetime(2008, 3, 31): datetime(2008, 5, 1),
+                datetime(2008, 4, 15): datetime(2008, 5, 1),
+                datetime(2008, 4, 30): datetime(2008, 5, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 12, 1): datetime(2009, 1, 1),
+                datetime(2008, 1, 1): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 4, 1),
+                datetime(2008, 2, 29): datetime(2008, 4, 1),
+                datetime(2008, 3, 15): datetime(2008, 4, 1),
+                datetime(2008, 3, 31): datetime(2008, 4, 1),
+                datetime(2008, 4, 15): datetime(2008, 7, 1),
+                datetime(2008, 4, 30): datetime(2008, 7, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 1),
+                datetime(2008, 1, 31): datetime(2008, 1, 1),
+                datetime(2008, 2, 15): datetime(2008, 1, 1),
+                datetime(2008, 2, 29): datetime(2008, 1, 1),
+                datetime(2008, 3, 15): datetime(2008, 1, 1),
+                datetime(2008, 3, 31): datetime(2008, 1, 1),
+                datetime(2008, 4, 15): datetime(2008, 4, 1),
+                datetime(2008, 4, 30): datetime(2008, 4, 1),
+                datetime(2008, 7, 1): datetime(2008, 4, 1),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterBegin(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 7, 1),
+                datetime(2008, 2, 15): datetime(2008, 7, 1),
+                datetime(2008, 2, 29): datetime(2008, 7, 1),
+                datetime(2008, 3, 15): datetime(2008, 7, 1),
+                datetime(2008, 3, 31): datetime(2008, 7, 1),
+                datetime(2008, 4, 15): datetime(2008, 10, 1),
+                datetime(2008, 4, 1): datetime(2008, 10, 1),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+
+class TestQuarterEnd:
+    def test_repr(self):
+        expected = "<QuarterEnd: startingMonth=3>"
+        assert repr(QuarterEnd()) == expected
+        expected = "<QuarterEnd: startingMonth=3>"
+        assert repr(QuarterEnd(startingMonth=3)) == expected
+        expected = "<QuarterEnd: startingMonth=1>"
+        assert repr(QuarterEnd(startingMonth=1)) == expected
+
+    def test_is_anchored(self):
+        msg = "QuarterEnd.is_anchored is deprecated "
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert QuarterEnd(startingMonth=1).is_anchored()
+            assert QuarterEnd().is_anchored()
+            assert not QuarterEnd(2, startingMonth=1).is_anchored()
+
+    def test_offset_corner_case(self):
+        # corner
+        offset = QuarterEnd(n=-1, startingMonth=1)
+        assert datetime(2010, 2, 1) + offset == datetime(2010, 1, 31)
+
+    offset_cases = []
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 4, 30),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 7, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=2),
+            {
+                datetime(2008, 1, 1): datetime(2008, 2, 29),
+                datetime(2008, 1, 31): datetime(2008, 2, 29),
+                datetime(2008, 2, 15): datetime(2008, 2, 29),
+                datetime(2008, 2, 29): datetime(2008, 5, 31),
+                datetime(2008, 3, 15): datetime(2008, 5, 31),
+                datetime(2008, 3, 31): datetime(2008, 5, 31),
+                datetime(2008, 4, 15): datetime(2008, 5, 31),
+                datetime(2008, 4, 30): datetime(2008, 5, 31),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=0),
+            {
+                datetime(2008, 1, 1): datetime(2008, 1, 31),
+                datetime(2008, 1, 31): datetime(2008, 1, 31),
+                datetime(2008, 2, 15): datetime(2008, 4, 30),
+                datetime(2008, 2, 29): datetime(2008, 4, 30),
+                datetime(2008, 3, 15): datetime(2008, 4, 30),
+                datetime(2008, 3, 31): datetime(2008, 4, 30),
+                datetime(2008, 4, 15): datetime(2008, 4, 30),
+                datetime(2008, 4, 30): datetime(2008, 4, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=-1),
+            {
+                datetime(2008, 1, 1): datetime(2007, 10, 31),
+                datetime(2008, 1, 31): datetime(2007, 10, 31),
+                datetime(2008, 2, 15): datetime(2008, 1, 31),
+                datetime(2008, 2, 29): datetime(2008, 1, 31),
+                datetime(2008, 3, 15): datetime(2008, 1, 31),
+                datetime(2008, 3, 31): datetime(2008, 1, 31),
+                datetime(2008, 4, 15): datetime(2008, 1, 31),
+                datetime(2008, 4, 30): datetime(2008, 1, 31),
+                datetime(2008, 7, 1): datetime(2008, 4, 30),
+            },
+        )
+    )
+
+    offset_cases.append(
+        (
+            QuarterEnd(startingMonth=1, n=2),
+            {
+                datetime(2008, 1, 31): datetime(2008, 7, 31),
+                datetime(2008, 2, 15): datetime(2008, 7, 31),
+                datetime(2008, 2, 29): datetime(2008, 7, 31),
+                datetime(2008, 3, 15): datetime(2008, 7, 31),
+                datetime(2008, 3, 31): datetime(2008, 7, 31),
+                datetime(2008, 4, 15): datetime(2008, 7, 31),
+                datetime(2008, 4, 30): datetime(2008, 10, 31),
+            },
+        )
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        offset, cases = case
+        for base, expected in cases.items():
+            assert_offset_equal(offset, base, expected)
+
+    on_offset_cases = [
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 1, 31), True),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 12, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 2, 29), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 3, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 4, 30), True),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2008, 5, 31), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=1), datetime(2007, 6, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 1, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 12, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 2, 29), True),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 3, 31), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 4, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2008, 5, 31), True),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=2), datetime(2007, 6, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 1, 31), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 12, 31), True),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 2, 29), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 3, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 3, 31), True),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 4, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 5, 30), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2008, 5, 31), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 6, 29), False),
+        (QuarterEnd(1, startingMonth=3), datetime(2007, 6, 30), True),
+    ]
+
+    @pytest.mark.parametrize("case", on_offset_cases)
+    def test_is_on_offset(self, case):
+        offset, dt, expected = case
+        assert_is_on_offset(offset, dt, expected)

llava_next/lib/python3.10/site-packages/pandas/tests/tseries/offsets/test_ticks.py

@@ -0,0 +1,405 @@
+"""
+Tests for offsets.Tick and subclasses
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+from hypothesis import (
+    assume,
+    example,
+    given,
+)
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import delta_to_tick
+from pandas.errors import OutOfBoundsTimedelta
+
+from pandas import (
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas._testing._hypothesis import INT_NEG_999_TO_POS_999
+from pandas.tests.tseries.offsets.common import assert_offset_equal
+
+from pandas.tseries import offsets
+from pandas.tseries.offsets import (
+    Hour,
+    Micro,
+    Milli,
+    Minute,
+    Nano,
+    Second,
+)
+
+# ---------------------------------------------------------------------
+# Test Helpers
+
+tick_classes = [Hour, Minute, Second, Milli, Micro, Nano]
+
+
+# ---------------------------------------------------------------------
+
+
+def test_apply_ticks():
+    result = offsets.Hour(3) + offsets.Hour(4)
+    exp = offsets.Hour(7)
+    assert result == exp
+
+
+def test_delta_to_tick():
+    delta = timedelta(3)
+
+    tick = delta_to_tick(delta)
+    assert tick == offsets.Day(3)
+
+    td = Timedelta(nanoseconds=5)
+    tick = delta_to_tick(td)
+    assert tick == Nano(5)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+@example(n=2, m=3)
+@example(n=800, m=300)
+@example(n=1000, m=5)
+@given(n=INT_NEG_999_TO_POS_999, m=INT_NEG_999_TO_POS_999)
+def test_tick_add_sub(cls, n, m):
+    # For all Tick subclasses and all integers n, m, we should have
+    # tick(n) + tick(m) == tick(n+m)
+    # tick(n) - tick(m) == tick(n-m)
+    left = cls(n)
+    right = cls(m)
+    expected = cls(n + m)
+
+    assert left + right == expected
+
+    expected = cls(n - m)
+    assert left - right == expected
+
+
+@pytest.mark.arm_slow
+@pytest.mark.parametrize("cls", tick_classes)
+@example(n=2, m=3)
+@given(n=INT_NEG_999_TO_POS_999, m=INT_NEG_999_TO_POS_999)
+def test_tick_equality(cls, n, m):
+    assume(m != n)
+    # tick == tock iff tick.n == tock.n
+    left = cls(n)
+    right = cls(m)
+    assert left != right
+
+    right = cls(n)
+    assert left == right
+    assert not left != right
+
+    if n != 0:
+        assert cls(n) != cls(-n)
+
+
+# ---------------------------------------------------------------------
+
+
+def test_Hour():
+    assert_offset_equal(Hour(), datetime(2010, 1, 1), datetime(2010, 1, 1, 1))
+    assert_offset_equal(Hour(-1), datetime(2010, 1, 1, 1), datetime(2010, 1, 1))
+    assert_offset_equal(2 * Hour(), datetime(2010, 1, 1), datetime(2010, 1, 1, 2))
+    assert_offset_equal(-1 * Hour(), datetime(2010, 1, 1, 1), datetime(2010, 1, 1))
+
+    assert Hour(3) + Hour(2) == Hour(5)
+    assert Hour(3) - Hour(2) == Hour()
+
+    assert Hour(4) != Hour(1)
+
+
+def test_Minute():
+    assert_offset_equal(Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 1))
+    assert_offset_equal(Minute(-1), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
+    assert_offset_equal(2 * Minute(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 2))
+    assert_offset_equal(-1 * Minute(), datetime(2010, 1, 1, 0, 1), datetime(2010, 1, 1))
+
+    assert Minute(3) + Minute(2) == Minute(5)
+    assert Minute(3) - Minute(2) == Minute()
+    assert Minute(5) != Minute()
+
+
+def test_Second():
+    assert_offset_equal(Second(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 1))
+    assert_offset_equal(Second(-1), datetime(2010, 1, 1, 0, 0, 1), datetime(2010, 1, 1))
+    assert_offset_equal(
+        2 * Second(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 2)
+    )
+    assert_offset_equal(
+        -1 * Second(), datetime(2010, 1, 1, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert Second(3) + Second(2) == Second(5)
+    assert Second(3) - Second(2) == Second()
+
+
+def test_Millisecond():
+    assert_offset_equal(
+        Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 1000)
+    )
+    assert_offset_equal(
+        Milli(-1), datetime(2010, 1, 1, 0, 0, 0, 1000), datetime(2010, 1, 1)
+    )
+    assert_offset_equal(
+        Milli(2), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2000)
+    )
+    assert_offset_equal(
+        2 * Milli(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2000)
+    )
+    assert_offset_equal(
+        -1 * Milli(), datetime(2010, 1, 1, 0, 0, 0, 1000), datetime(2010, 1, 1)
+    )
+
+    assert Milli(3) + Milli(2) == Milli(5)
+    assert Milli(3) - Milli(2) == Milli()
+
+
+def test_MillisecondTimestampArithmetic():
+    assert_offset_equal(
+        Milli(), Timestamp("2010-01-01"), Timestamp("2010-01-01 00:00:00.001")
+    )
+    assert_offset_equal(
+        Milli(-1), Timestamp("2010-01-01 00:00:00.001"), Timestamp("2010-01-01")
+    )
+
+
+def test_Microsecond():
+    assert_offset_equal(Micro(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 1))
+    assert_offset_equal(
+        Micro(-1), datetime(2010, 1, 1, 0, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert_offset_equal(
+        2 * Micro(), datetime(2010, 1, 1), datetime(2010, 1, 1, 0, 0, 0, 2)
+    )
+    assert_offset_equal(
+        -1 * Micro(), datetime(2010, 1, 1, 0, 0, 0, 1), datetime(2010, 1, 1)
+    )
+
+    assert Micro(3) + Micro(2) == Micro(5)
+    assert Micro(3) - Micro(2) == Micro()
+
+
+def test_NanosecondGeneric():
+    timestamp = Timestamp(datetime(2010, 1, 1))
+    assert timestamp.nanosecond == 0
+
+    result = timestamp + Nano(10)
+    assert result.nanosecond == 10
+
+    reverse_result = Nano(10) + timestamp
+    assert reverse_result.nanosecond == 10
+
+
+def test_Nanosecond():
+    timestamp = Timestamp(datetime(2010, 1, 1))
+    assert_offset_equal(Nano(), timestamp, timestamp + np.timedelta64(1, "ns"))
+    assert_offset_equal(Nano(-1), timestamp + np.timedelta64(1, "ns"), timestamp)
+    assert_offset_equal(2 * Nano(), timestamp, timestamp + np.timedelta64(2, "ns"))
+    assert_offset_equal(-1 * Nano(), timestamp + np.timedelta64(1, "ns"), timestamp)
+
+    assert Nano(3) + Nano(2) == Nano(5)
+    assert Nano(3) - Nano(2) == Nano()
+
+    # GH9284
+    assert Nano(1) + Nano(10) == Nano(11)
+    assert Nano(5) + Micro(1) == Nano(1005)
+    assert Micro(5) + Nano(1) == Nano(5001)
+
+
+@pytest.mark.parametrize(
+    "kls, expected",
+    [
+        (Hour, Timedelta(hours=5)),
+        (Minute, Timedelta(hours=2, minutes=3)),
+        (Second, Timedelta(hours=2, seconds=3)),
+        (Milli, Timedelta(hours=2, milliseconds=3)),
+        (Micro, Timedelta(hours=2, microseconds=3)),
+        (Nano, Timedelta(hours=2, nanoseconds=3)),
+    ],
+)
+def test_tick_addition(kls, expected):
+    offset = kls(3)
+    td = Timedelta(hours=2)
+
+    for other in [td, td.to_pytimedelta(), td.to_timedelta64()]:
+        result = offset + other
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = other + offset
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+
+def test_tick_delta_overflow():
+    # GH#55503 raise OutOfBoundsTimedelta, not OverflowError
+    tick = offsets.Day(10**9)
+    msg = "Cannot cast 1000000000 days 00:00:00 to unit='ns' without overflow"
+    depr_msg = "Day.delta is deprecated"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            tick.delta
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_division(cls):
+    off = cls(10)
+
+    assert off / cls(5) == 2
+    assert off / 2 == cls(5)
+    assert off / 2.0 == cls(5)
+
+    assert off / off._as_pd_timedelta == 1
+    assert off / off._as_pd_timedelta.to_timedelta64() == 1
+
+    assert off / Nano(1) == off._as_pd_timedelta / Nano(1)._as_pd_timedelta
+
+    if cls is not Nano:
+        # A case where we end up with a smaller class
+        result = off / 1000
+        assert isinstance(result, offsets.Tick)
+        assert not isinstance(result, cls)
+        assert result._as_pd_timedelta == off._as_pd_timedelta / 1000
+
+    if cls._nanos_inc < Timedelta(seconds=1)._value:
+        # Case where we end up with a bigger class
+        result = off / 0.001
+        assert isinstance(result, offsets.Tick)
+        assert not isinstance(result, cls)
+        assert result._as_pd_timedelta == off._as_pd_timedelta / 0.001
+
+
+def test_tick_mul_float():
+    off = Micro(2)
+
+    # Case where we retain type
+    result = off * 1.5
+    expected = Micro(3)
+    assert result == expected
+    assert isinstance(result, Micro)
+
+    # Case where we bump up to the next type
+    result = off * 1.25
+    expected = Nano(2500)
+    assert result == expected
+    assert isinstance(result, Nano)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_rdiv(cls):
+    off = cls(10)
+    delta = off._as_pd_timedelta
+    td64 = delta.to_timedelta64()
+    instance__type = ".".join([cls.__module__, cls.__name__])
+    msg = (
+        "unsupported operand type\\(s\\) for \\/: 'int'|'float' and "
+        f"'{instance__type}'"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        2 / off
+    with pytest.raises(TypeError, match=msg):
+        2.0 / off
+
+    assert (td64 * 2.5) / off == 2.5
+
+    if cls is not Nano:
+        # skip pytimedelta for Nano since it gets dropped
+        assert (delta.to_pytimedelta() * 2) / off == 2
+
+    result = np.array([2 * td64, td64]) / off
+    expected = np.array([2.0, 1.0])
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("cls1", tick_classes)
+@pytest.mark.parametrize("cls2", tick_classes)
+def test_tick_zero(cls1, cls2):
+    assert cls1(0) == cls2(0)
+    assert cls1(0) + cls2(0) == cls1(0)
+
+    if cls1 is not Nano:
+        assert cls1(2) + cls2(0) == cls1(2)
+
+    if cls1 is Nano:
+        assert cls1(2) + Nano(0) == cls1(2)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_equalities(cls):
+    assert cls() == cls(1)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_tick_offset(cls):
+    msg = f"{cls.__name__}.is_anchored is deprecated "
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert not cls().is_anchored()
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_compare_ticks(cls):
+    three = cls(3)
+    four = cls(4)
+
+    assert three < cls(4)
+    assert cls(3) < four
+    assert four > cls(3)
+    assert cls(4) > three
+    assert cls(3) == cls(3)
+    assert cls(3) != cls(4)
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_compare_ticks_to_strs(cls):
+    # GH#23524
+    off = cls(19)
+
+    # These tests should work with any strings, but we particularly are
+    #  interested in "infer" as that comparison is convenient to make in
+    #  Datetime/Timedelta Array/Index constructors
+    assert not off == "infer"
+    assert not "foo" == off
+
+    instance_type = ".".join([cls.__module__, cls.__name__])
+    msg = (
+        "'<'|'<='|'>'|'>=' not supported between instances of "
+        f"'str' and '{instance_type}'|'{instance_type}' and 'str'"
+    )
+
+    for left, right in [("infer", off), (off, "infer")]:
+        with pytest.raises(TypeError, match=msg):
+            left < right
+        with pytest.raises(TypeError, match=msg):
+            left <= right
+        with pytest.raises(TypeError, match=msg):
+            left > right
+        with pytest.raises(TypeError, match=msg):
+            left >= right
+
+
+@pytest.mark.parametrize("cls", tick_classes)
+def test_compare_ticks_to_timedeltalike(cls):
+    off = cls(19)
+
+    td = off._as_pd_timedelta
+
+    others = [td, td.to_timedelta64()]
+    if cls is not Nano:
+        others.append(td.to_pytimedelta())
+
+    for other in others:
+        assert off == other
+        assert not off != other
+        assert not off < other
+        assert not off > other
+        assert off <= other
+        assert off >= other