text: """
  Tests for CBMonthEnd CBMonthBegin, SemiMonthEnd, and SemiMonthBegin in offsets
  """
  from datetime import date, datetime
  
  import numpy as np
  import pytest
  
  from pandas._libs.tslibs import Timestamp
  from pandas._libs.tslibs.offsets import (
      CBMonthBegin,
      CBMonthEnd,
      CDay,
      SemiMonthBegin,
      SemiMonthEnd,
  )
  
  from pandas import DatetimeIndex, Series, _testing as tm, date_range
  from pandas.tests.tseries.offsets.common import (
      Base,
      assert_is_on_offset,
      assert_offset_equal,
  )
  from pandas.tests.tseries.offsets.test_offsets import _ApplyCases
  
  from pandas.tseries import offsets as offsets
  from pandas.tseries.holiday import USFederalHolidayCalendar
  
  
  class CustomBusinessMonthBase:
      def setup_method(self, method):
          self.d = datetime(2008, 1, 1)
  
          self.offset = self._offset()
          self.offset1 = self.offset
          self.offset2 = self._offset(2)
  
      def test_eq(self):
          assert self.offset2 == self.offset2
  
      def test_mul(self):
          pass
  
      def test_hash(self):
          assert hash(self.offset2) == hash(self.offset2)
  
      def test_roundtrip_pickle(self):
          def _check_roundtrip(obj):
              unpickled = tm.round_trip_pickle(obj)
              assert unpickled == obj
  
          _check_roundtrip(self._offset())
          _check_roundtrip(self._offset(2))
          _check_roundtrip(self._offset() * 2)
  
      def test_copy(self):
          # GH 17452
          off = self._offset(weekmask="Mon Wed Fri")
          assert off == off.copy()
  
  
  class TestCustomBusinessMonthEnd(CustomBusinessMonthBase, Base):
      _offset = CBMonthEnd
  
      def test_different_normalize_equals(self):
          # GH#21404 changed __eq__ to return False when `normalize` does not match
          offset = self._offset()
          offset2 = self._offset(normalize=True)
          assert offset != offset2
  
      def test_repr(self):
          assert repr(self.offset) == "<CustomBusinessMonthEnd>"
          assert repr(self.offset2) == "<2 * CustomBusinessMonthEnds>"
  
      def test_call(self):
          with tm.assert_produces_warning(FutureWarning):
              # GH#34171 DateOffset.__call__ is deprecated
              assert self.offset2(self.d) == datetime(2008, 2, 29)
  
      def testRollback1(self):
          assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
  
      def testRollback2(self):
          assert CBMonthEnd(10).rollback(self.d) == datetime(2007, 12, 31)
  
      def testRollforward1(self):
          assert CBMonthEnd(10).rollforward(self.d) == 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, d, expected = case
          assert_is_on_offset(offset, d, expected)
  
      apply_cases: _ApplyCases = [
          (
              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.filterwarnings("ignore:Non:pandas.errors.PerformanceWarning")
      def test_datetimeindex(self):
          from pandas.tseries.holiday import USFederalHolidayCalendar
  
          hcal = USFederalHolidayCalendar()
          freq = CBMonthEnd(calendar=hcal)
  
          assert date_range(start="20120101", end="20130101", freq=freq).tolist()[
              0
          ] == datetime(2012, 1, 31)
  
  
  class TestCustomBusinessMonthBegin(CustomBusinessMonthBase, Base):
      _offset = CBMonthBegin
  
      def test_different_normalize_equals(self):
          # GH#21404 changed __eq__ to return False when `normalize` does not match
          offset = self._offset()
          offset2 = self._offset(normalize=True)
          assert offset != offset2
  
      def test_repr(self):
          assert repr(self.offset) == "<CustomBusinessMonthBegin>"
          assert repr(self.offset2) == "<2 * CustomBusinessMonthBegins>"
  
      def test_call(self):
          with tm.assert_produces_warning(FutureWarning):
              # GH#34171 DateOffset.__call__ is deprecated
              assert self.offset2(self.d) == datetime(2008, 3, 3)
  
      def testRollback1(self):
          assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
  
      def testRollback2(self):
          assert CBMonthBegin(10).rollback(self.d) == datetime(2008, 1, 1)
  
      def testRollforward1(self):
          assert CBMonthBegin(10).rollforward(self.d) == 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: _ApplyCases = [
          (
              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.filterwarnings("ignore:Non:pandas.errors.PerformanceWarning")
      def test_datetimeindex(self):
          hcal = USFederalHolidayCalendar()
          cbmb = CBMonthBegin(calendar=hcal)
          assert date_range(start="20120101", end="20130101", freq=cbmb).tolist()[
              0
          ] == datetime(2012, 1, 3)
  
  
  class TestSemiMonthEnd(Base):
      _offset = SemiMonthEnd
      offset1 = _offset()
      offset2 = _offset(2)
  
      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
          s = 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() + s
  
          exp = DatetimeIndex(dates[1:])
          tm.assert_index_equal(result, exp)
  
          # ensure generating a range with DatetimeIndex gives same result
          result = date_range(start=dates[0], end=dates[-1], freq="SM")
          exp = DatetimeIndex(dates, freq="SM")
          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
          s = 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 + s
          tm.assert_index_equal(result, exp)
  
          with tm.assert_produces_warning(FutureWarning):
              result = offset.apply_index(s)
          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):
          s = 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 = s + SemiMonthEnd()
              result2 = SemiMonthEnd() + s
  
          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)
  
          s = 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 = s + SemiMonthEnd()
              result2 = SemiMonthEnd() + s
  
          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(Base):
      _offset = SemiMonthBegin
      offset1 = _offset()
      offset2 = _offset(2)
  
      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
          s = 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() + s
  
          exp = DatetimeIndex(dates[1:])
          tm.assert_index_equal(result, exp)
  
          # ensure generating a range with DatetimeIndex gives same result
          result = date_range(start=dates[0], end=dates[-1], freq="SMS")
          exp = DatetimeIndex(dates, freq="SMS")
          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
          s = 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 + s
  
          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):
          s = 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 = s + SemiMonthBegin()
              result2 = SemiMonthBegin() + s
  
          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)
  
          s = 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 = s + SemiMonthBegin()
              result2 = SemiMonthBegin() + s
  
          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)
  