/pandas/tseries/tests/test_offsets.py

Large files files are truncated, but you can click here to view the full file

from datetime import date, datetime, timedelta
from dateutil.relativedelta import relativedelta
from pandas.compat import range
from pandas import compat
import nose
from nose.tools import assert_raises


import numpy as np

from pandas.core.datetools import (
    bday, BDay, CDay, BQuarterEnd, BMonthEnd,
    CBMonthEnd, CBMonthBegin,
    BYearEnd, MonthEnd, MonthBegin, BYearBegin,
    QuarterBegin, BQuarterBegin, BMonthBegin, DateOffset, Week,
    YearBegin, YearEnd, Hour, Minute, Second, Day, Micro, Milli, Nano, Easter,
    WeekOfMonth, format, ole2datetime, QuarterEnd, to_datetime, normalize_date,
    get_offset, get_offset_name, get_standard_freq)

from pandas.tseries.frequencies import _offset_map
from pandas.tseries.index import _to_m8, DatetimeIndex, _daterange_cache, date_range
from pandas.tseries.tools import parse_time_string, _maybe_get_tz
import pandas.tseries.offsets as offsets

from pandas.tslib import monthrange, OutOfBoundsDatetime, NaT
from pandas.lib import Timestamp
from pandas.util.testing import assertRaisesRegexp
import pandas.util.testing as tm
from pandas.tseries.offsets import BusinessMonthEnd, CacheableOffset, \
    LastWeekOfMonth, FY5253, FY5253Quarter, WeekDay
from pandas.tseries.holiday import USFederalHolidayCalendar

from pandas import _np_version_under1p7

_multiprocess_can_split_ = True


def test_monthrange():
    import calendar
    for y in range(2000, 2013):
        for m in range(1, 13):
            assert monthrange(y, m) == calendar.monthrange(y, m)


####
## Misc function tests
####


def test_format():
    actual = format(datetime(2008, 1, 15))
    assert actual == '20080115'


def test_ole2datetime():
    actual = ole2datetime(60000)
    assert actual == datetime(2064, 4, 8)

    assert_raises(ValueError, ole2datetime, 60)


def test_to_datetime1():
    actual = to_datetime(datetime(2008, 1, 15))
    assert actual == datetime(2008, 1, 15)

    actual = to_datetime('20080115')
    assert actual == datetime(2008, 1, 15)

    # unparseable
    s = 'Month 1, 1999'
    assert to_datetime(s) == s


def test_normalize_date():
    actual = normalize_date(datetime(2007, 10, 1, 1, 12, 5, 10))
    assert actual == datetime(2007, 10, 1)


def test_to_m8():
    valb = datetime(2007, 10, 1)
    valu = _to_m8(valb)
    tm.assert_isinstance(valu, np.datetime64)
    # assert valu == np.datetime64(datetime(2007,10,1))

# def test_datetime64_box():
#    valu = np.datetime64(datetime(2007,10,1))
#    valb = _dt_box(valu)
#    assert type(valb) == datetime
#    assert valb == datetime(2007,10,1)

#####
### DateOffset Tests
#####

class Base(tm.TestCase):
    _offset = None

    _offset_types = [getattr(offsets, o) for o in offsets.__all__]
    skip_np_u1p7 = [offsets.CustomBusinessDay, offsets.CDay, offsets.CustomBusinessMonthBegin,
                    offsets.CustomBusinessMonthEnd, offsets.Nano]

    @property
    def offset_types(self):
        if _np_version_under1p7:
            return [o for o in self._offset_types if o not in self.skip_np_u1p7]
        else:
            return self._offset_types

    def _get_offset(self, klass, value=1, normalize=False):
        # create instance from offset class
        if klass is FY5253 or 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)
        else:
            try:
                klass = klass(value, normalize=normalize)
            except:
                klass = klass(normalize=normalize)
        return klass

    def test_apply_out_of_range(self):
        if self._offset is None:
            return
        if _np_version_under1p7 and self._offset in self.skip_np_u1p7:
            raise nose.SkipTest('numpy >= 1.7 required')

        # try to create an out-of-bounds result timestamp; if we can't create the offset
        # skip
        try:
            offset = self._get_offset(self._offset, value=10000)

            result = Timestamp('20080101') + offset
            self.assertIsInstance(result, datetime)
        except (OutOfBoundsDatetime):
            raise
        except (ValueError, KeyError) as e:
            raise nose.SkipTest("cannot create out_of_range offset: {0} {1}".format(str(self).split('.')[-1],e))


class TestCommon(Base):

    def setUp(self):

        # exected value created by Base._get_offset
        # are applied to 2011/01/01 09:00 (Saturday)
        # used for .apply and .rollforward
        self.expecteds = {'Day': 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'),
                          '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'),
                          '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(np.datetime64('2011-01-01T09:00:00.000000001Z'))}

        self.timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern']

    def test_return_type(self):
        for offset in self.offset_types:
            offset = self._get_offset(offset)

            # make sure that we are returning a Timestamp
            result = Timestamp('20080101') + offset
            self.assertIsInstance(result, Timestamp)

            # make sure that we are returning NaT
            self.assertTrue(NaT + offset is NaT)
            self.assertTrue(offset + NaT is NaT)

            self.assertTrue(NaT - offset is NaT)
            self.assertTrue((-offset).apply(NaT) is NaT)

    def _check_offsetfunc_works(self, offset, funcname, dt, expected,
                                normalize=False):
        offset_s = self._get_offset(offset, normalize=normalize)
        func = getattr(offset_s, funcname)

        result = func(dt)
        self.assert_(isinstance(result, Timestamp))
        self.assertEqual(result, expected)

        result = func(Timestamp(dt))
        self.assert_(isinstance(result, Timestamp))
        self.assertEqual(result, expected)

        if isinstance(dt, np.datetime64):
            # test tz when input is datetime or Timestamp
            return

        tm._skip_if_no_pytz()
        import pytz
        for tz in self.timezones:
            expected_localize = expected.tz_localize(tz)

            dt_tz = pytz.timezone(tz).localize(dt)
            result = func(dt_tz)
            self.assert_(isinstance(result, Timestamp))
            self.assertEqual(result, expected_localize)

            result = func(Timestamp(dt, tz=tz))
            self.assert_(isinstance(result, Timestamp))
            self.assertEqual(result, expected_localize)

    def _check_nanofunc_works(self, offset, funcname, dt, expected):
        offset = self._get_offset(offset)
        func = getattr(offset, funcname)

        t1 = Timestamp(dt)
        self.assertEqual(func(t1), expected)

    def test_apply(self):
        sdt = datetime(2011, 1, 1, 9, 0)
        ndt = np.datetime64('2011-01-01 09:00Z')

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = self.expecteds[offset.__name__]
                if offset == Nano:
                    self._check_nanofunc_works(offset, 'apply', dt, expected)
                else:
                    self._check_offsetfunc_works(offset, 'apply', dt, expected)

                    expected = Timestamp(expected.date())
                    self._check_offsetfunc_works(offset, 'apply', dt, expected,
                                                 normalize=True)

    def test_rollforward(self):
        expecteds = self.expecteds.copy()

        # result will not be changed if the target is on the offset
        no_changes = ['Day', 'MonthBegin', 'YearBegin', 'Week', 'Hour', 'Minute',
                      'Second', 'Milli', 'Micro', 'Nano']
        for n in no_changes:
            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('2011-01-02 00:00:00'),
                      'MonthBegin': Timestamp('2011-02-01 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:00Z')

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = expecteds[offset.__name__]
                if offset == Nano:
                    self._check_nanofunc_works(offset, 'rollforward', dt, expected)
                else:
                    self._check_offsetfunc_works(offset, 'rollforward', dt, expected)
                    expected = norm_expected[offset.__name__]
                    self._check_offsetfunc_works(offset, 'rollforward', dt, expected,
                                                 normalize=True)

    def test_rollback(self):
        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'),
                     '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'),
                     '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', 'YearBegin', 'Week', 'Hour', 'Minute',
                  'Second', 'Milli', 'Micro', 'Nano']:
            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'),
                      'MonthBegin': Timestamp('2010-12-01 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:00Z')

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = expecteds[offset.__name__]
                if offset == Nano:
                    self._check_nanofunc_works(offset, 'rollback', dt, expected)
                else:
                    self._check_offsetfunc_works(offset, 'rollback', dt, expected)

                    expected = norm_expected[offset.__name__]
                    self._check_offsetfunc_works(offset, 'rollback',
                                                 dt, expected, normalize=True)

    def test_onOffset(self):
        for offset in self.offset_types:
            dt = self.expecteds[offset.__name__]
            offset_s = self._get_offset(offset)
            self.assert_(offset_s.onOffset(dt))

            # when normalize=True, onOffset checks time is 00:00:00
            offset_n = self._get_offset(offset, normalize=True)
            self.assert_(not offset_n.onOffset(dt))

            date = datetime(dt.year, dt.month, dt.day)
            self.assert_(offset_n.onOffset(date))

    def test_add(self):
        dt = datetime(2011, 1, 1, 9, 0)

        for offset in self.offset_types:
            offset_s = self._get_offset(offset)
            expected = self.expecteds[offset.__name__]

            result_dt = dt + offset_s
            result_ts = Timestamp(dt) + offset_s
            for result in [result_dt, result_ts]:
                self.assertTrue(isinstance(result, Timestamp))
                self.assertEqual(result, expected)

            tm._skip_if_no_pytz()
            for tz in self.timezones:
                expected_localize = expected.tz_localize(tz)
                result = Timestamp(dt, tz=tz) + offset_s
                self.assert_(isinstance(result, Timestamp))
                self.assertEqual(result, expected_localize)

            # normalize=True
            offset_s = self._get_offset(offset, normalize=True)
            expected = Timestamp(expected.date())

            result_dt = dt + offset_s
            result_ts = Timestamp(dt) + offset_s
            for result in [result_dt, result_ts]:
                self.assertTrue(isinstance(result, Timestamp))
                self.assertEqual(result, expected)

            for tz in self.timezones:
                expected_localize = expected.tz_localize(tz)
                result = Timestamp(dt, tz=tz) + offset_s
                self.assert_(isinstance(result, Timestamp))
                self.assertEqual(result, expected_localize)


class TestDateOffset(Base):
    _multiprocess_can_split_ = True

    def setUp(self):
        self.d = Timestamp(datetime(2008, 1, 2))
        _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

    def test_constructor(self):

        assert((self.d + DateOffset(months=2)) == datetime(2008, 3, 2))
        assert((self.d - DateOffset(months=2)) == datetime(2007, 11, 2))

        assert((self.d + DateOffset(2)) == datetime(2008, 1, 4))

        assert not DateOffset(2).isAnchored()
        assert DateOffset(1).isAnchored()

        d = datetime(2008, 1, 31)
        assert((d + DateOffset(months=1)) == datetime(2008, 2, 29))

    def test_copy(self):
        assert(DateOffset(months=2).copy() == DateOffset(months=2))

    def test_eq(self):
        offset1 = DateOffset(days=1)
        offset2 = DateOffset(days=365)

        self.assertNotEqual(offset1, offset2)


class TestBusinessDay(Base):
    _multiprocess_can_split_ = True
    _offset = BDay

    def setUp(self):
        self.d = datetime(2008, 1, 1)

        self.offset = BDay()
        self.offset2 = BDay(2)

    def test_different_normalize_equals(self):
        # equivalent in this special case
        offset = BDay()
        offset2 = BDay()
        offset2.normalize = True
        self.assertEqual(offset, offset2)

    def test_repr(self):
        self.assertEqual(repr(self.offset), '<BusinessDay>')
        assert repr(self.offset2) == '<2 * BusinessDays>'

        expected = '<BusinessDay: offset=datetime.timedelta(1)>'
        assert repr(self.offset + timedelta(1)) == expected

    def test_with_offset(self):
        offset = self.offset + timedelta(hours=2)

        assert (self.d + offset) == datetime(2008, 1, 2, 2)

    def testEQ(self):
        self.assertEqual(self.offset2, self.offset2)

    def test_mul(self):
        pass

    def test_hash(self):
        self.assertEqual(hash(self.offset2), hash(self.offset2))

    def testCall(self):
        self.assertEqual(self.offset2(self.d), datetime(2008, 1, 3))

    def testRAdd(self):
        self.assertEqual(self.d + self.offset2, self.offset2 + self.d)

    def testSub(self):
        off = self.offset2
        self.assertRaises(Exception, off.__sub__, self.d)
        self.assertEqual(2 * off - off, off)

        self.assertEqual(self.d - self.offset2, self.d + BDay(-2))

    def testRSub(self):
        self.assertEqual(self.d - self.offset2, (-self.offset2).apply(self.d))

    def testMult1(self):
        self.assertEqual(self.d + 10 * self.offset, self.d + BDay(10))

    def testMult2(self):
        self.assertEqual(self.d + (-5 * BDay(-10)),
                         self.d + BDay(50))

    def testRollback1(self):
        self.assertEqual(BDay(10).rollback(self.d), self.d)

    def testRollback2(self):
        self.assertEqual(
            BDay(10).rollback(datetime(2008, 1, 5)), datetime(2008, 1, 4))

    def testRollforward1(self):
        self.assertEqual(BDay(10).rollforward(self.d), self.d)

    def testRollforward2(self):
        self.assertEqual(
            BDay(10).rollforward(datetime(2008, 1, 5)), datetime(2008, 1, 7))

    def test_roll_date_object(self):
        offset = BDay()

        dt = date(2012, 9, 15)

        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 14))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 17))

        offset = offsets.Day()
        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

    def test_onOffset(self):
        tests = [(BDay(), datetime(2008, 1, 1), True),
                 (BDay(), datetime(2008, 1, 5), False)]

        for offset, date, expected in tests:
            assertOnOffset(offset, date, expected)

    def test_apply(self):
        tests = []

        tests.append((bday,
                      {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)}))

        tests.append((2 * bday,
                      {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)}))

        tests.append((-bday,
                      {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)}))

        tests.append((-2 * bday,
                      {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)}))

        tests.append((BDay(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)}))

        for offset, cases in tests:
            for base, expected in compat.iteritems(cases):
                assertEq(offset, base, expected)

    def test_apply_large_n(self):
        dt = datetime(2012, 10, 23)

        result = dt + BDay(10)
        self.assertEqual(result, datetime(2012, 11, 6))

        result = dt + BDay(100) - BDay(100)
        self.assertEqual(result, dt)

        off = BDay() * 6
        rs = datetime(2012, 1, 1) - off
        xp = datetime(2011, 12, 23)
        self.assertEqual(rs, xp)

        st = datetime(2011, 12, 18)
        rs = st + off
        xp = datetime(2011, 12, 26)
        self.assertEqual(rs, xp)

        off = BDay() * 10
        rs = datetime(2014, 1, 5) + off # see #5890
        xp = datetime(2014, 1, 17)
        self.assertEqual(rs, xp)

    def test_apply_corner(self):
        self.assertRaises(TypeError, BDay().apply, BMonthEnd())

    def test_offsets_compare_equal(self):
        # root cause of #456
        offset1 = BDay()
        offset2 = BDay()
        self.assertFalse(offset1 != offset2)


class TestCustomBusinessDay(Base):
    _multiprocess_can_split_ = True
    _offset = CDay

    def setUp(self):
        self.d = datetime(2008, 1, 1)
        self.nd = np.datetime64('2008-01-01 00:00:00Z')

        tm._skip_if_no_cday()
        self.offset = CDay()
        self.offset2 = CDay(2)

    def test_different_normalize_equals(self):
        # equivalent in this special case
        offset = CDay()
        offset2 = CDay()
        offset2.normalize = True
        self.assertEqual(offset, offset2)

    def test_repr(self):
        assert repr(self.offset) == '<CustomBusinessDay>'
        assert repr(self.offset2) == '<2 * CustomBusinessDays>'

        expected = '<BusinessDay: offset=datetime.timedelta(1)>'
        assert repr(self.offset + timedelta(1)) == expected

    def test_with_offset(self):
        offset = self.offset + timedelta(hours=2)

        assert (self.d + offset) == datetime(2008, 1, 2, 2)

    def testEQ(self):
        self.assertEqual(self.offset2, self.offset2)

    def test_mul(self):
        pass

    def test_hash(self):
        self.assertEqual(hash(self.offset2), hash(self.offset2))

    def testCall(self):
        self.assertEqual(self.offset2(self.d), datetime(2008, 1, 3))
        self.assertEqual(self.offset2(self.nd), datetime(2008, 1, 3))

    def testRAdd(self):
        self.assertEqual(self.d + self.offset2, self.offset2 + self.d)

    def testSub(self):
        off = self.offset2
        self.assertRaises(Exception, off.__sub__, self.d)
        self.assertEqual(2 * off - off, off)

        self.assertEqual(self.d - self.offset2, self.d + CDay(-2))

    def testRSub(self):
        self.assertEqual(self.d - self.offset2, (-self.offset2).apply(self.d))

    def testMult1(self):
        self.assertEqual(self.d + 10 * self.offset, self.d + CDay(10))

    def testMult2(self):
        self.assertEqual(self.d + (-5 * CDay(-10)),
                         self.d + CDay(50))

    def testRollback1(self):
        self.assertEqual(CDay(10).rollback(self.d), self.d)

    def testRollback2(self):
        self.assertEqual(
            CDay(10).rollback(datetime(2008, 1, 5)), datetime(2008, 1, 4))

    def testRollforward1(self):
        self.assertEqual(CDay(10).rollforward(self.d), self.d)

    def testRollforward2(self):
        self.assertEqual(
            CDay(10).rollforward(datetime(2008, 1, 5)), datetime(2008, 1, 7))

    def test_roll_date_object(self):
        offset = CDay()

        dt = date(2012, 9, 15)

        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 14))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 17))

        offset = offsets.Day()
        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

    def test_onOffset(self):
        tests = [(CDay(), datetime(2008, 1, 1), True),
                 (CDay(), datetime(2008, 1, 5), False)]

        for offset, date, expected in tests:
            assertOnOffset(offset, date, expected)

    def test_apply(self):
        from pandas.core.datetools import cday
        tests = []

        tests.append((cday,
                      {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)}))

        tests.append((2 * cday,
                      {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)}))

        tests.append((-cday,
                      {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)}))

        tests.append((-2 * cday,
                      {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)}))

        tests.append((CDay(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)}))

        for offset, cases in tests:
            for base, expected in compat.iteritems(cases):
                assertEq(offset, base, expected)

    def test_apply_large_n(self):
        dt = datetime(2012, 10, 23)

        result = dt + CDay(10)
        self.assertEqual(result, datetime(2012, 11, 6))

        result = dt + CDay(100) - CDay(100)
        self.assertEqual(result, dt)

        off = CDay() * 6
        rs = datetime(2012, 1, 1) - off
        xp = datetime(2011, 12, 23)
        self.assertEqual(rs, xp)

        st = datetime(2011, 12, 18)
        rs = st + off
        xp = datetime(2011, 12, 26)
        self.assertEqual(rs, xp)

    def test_apply_corner(self):
        self.assertRaises(Exception, CDay().apply, BMonthEnd())

    def test_offsets_compare_equal(self):
        # root cause of #456
        offset1 = CDay()
        offset2 = CDay()
        self.assertFalse(offset1 != offset2)

    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
            self.assertEqual(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)
        self.assertEqual(xp_saudi, dt + bday_saudi)
        self.assertEqual(xp_uae, dt + bday_uae)
        self.assertEqual(xp_egypt, dt + bday_egypt)
        xp2 = datetime(2013, 5, 5)
        self.assertEqual(xp2, dt + 2 * bday_saudi)
        self.assertEqual(xp2, dt + 2 * bday_uae)
        self.assertEqual(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)
        self.assertEqual(xp_egypt, dt + 2 * bday_egypt)

    def test_calendar(self):
        calendar = USFederalHolidayCalendar()
        dt = datetime(2014, 1, 17)
        assertEq(CDay(calendar=calendar), dt, datetime(2014, 1, 21))

class CustomBusinessMonthBase(object):
    _multiprocess_can_split_ = True

    def setUp(self):
        self.d = datetime(2008, 1, 1)

        tm._skip_if_no_cday()
        self.offset = self._object()
        self.offset2 = self._object(2)

    def testEQ(self):
        self.assertEqual(self.offset2, self.offset2)

    def test_mul(self):
        pass

    def test_hash(self):
        self.assertEqual(hash(self.offset2), hash(self.offset2))

    def testRAdd(self):
        self.assertEqual(self.d + self.offset2, self.offset2 + self.d)

    def testSub(self):
        off = self.offset2
        self.assertRaises(Exception, off.__sub__, self.d)
        self.assertEqual(2 * off - off, off)

        self.assertEqual(self.d - self.offset2,
                         self.d + self._object(-2))

    def testRSub(self):
        self.assertEqual(self.d - self.offset2, (-self.offset2).apply(self.d))

    def testMult1(self):
        self.assertEqual(self.d + 10 * self.offset,
                         self.d + self._object(10))

    def testMult2(self):
        self.assertEqual(self.d + (-5 * self._object(-10)),
                         self.d + self._object(50))

    def test_offsets_compare_equal(self):
        offset1 = self._object()
        offset2 = self._object()
        self.assertFalse(offset1 != offset2)

class TestCustomBusinessMonthEnd(CustomBusinessMonthBase, Base):
    _object = CBMonthEnd

    def test_different_normalize_equals(self):
        # equivalent in this special case
        offset = CBMonthEnd()
        offset2 = CBMonthEnd()
        offset2.normalize = True
        self.assertEqual(offset, offset2)

    def test_repr(self):
        assert repr(self.offset) == '<CustomBusinessMonthEnd>'
        assert repr(self.offset2) == '<2 * CustomBusinessMonthEnds>'

    def testCall(self):
        self.assertEqual(self.offset2(self.d), datetime(2008, 2, 29))

    def testRollback1(self):
        self.assertEqual(
            CDay(10).rollback(datetime(2007, 12, 31)), datetime(2007, 12, 31))

    def testRollback2(self):
        self.assertEqual(CBMonthEnd(10).rollback(self.d),
                         datetime(2007,12,31))

    def testRollforward1(self):
        self.assertEqual(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)
        self.assertEqual(result, datetime(2012, 8, 31))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 28))

        offset = offsets.Day()
        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

    def test_onOffset(self):
        tests = [(CBMonthEnd(), datetime(2008, 1, 31), True),
                 (CBMonthEnd(), datetime(2008, 1, 1), False)]

        for offset, date, expected in tests:
            assertOnOffset(offset, date, expected)


    def test_apply(self):
        cbm = CBMonthEnd()
        tests = []

        tests.append((cbm,
                      {datetime(2008, 1, 1): datetime(2008, 1, 31),
                       datetime(2008, 2, 7): datetime(2008, 2, 29)}))

        tests.append((2 * cbm,
                      {datetime(2008, 1, 1): datetime(2008, 2, 29),
                       datetime(2008, 2, 7): datetime(2008, 3, 31)}))

        tests.append((-cbm,
                      {datetime(2008, 1, 1): datetime(2007, 12, 31),
                       datetime(2008, 2, 8): datetime(2008, 1, 31)}))

        tests.append((-2 * cbm,
                      {datetime(2008, 1, 1): datetime(2007, 11, 30),
                       datetime(2008, 2, 9): datetime(2007, 12, 31)}))

        tests.append((CBMonthEnd(0),
                      {datetime(2008, 1, 1): datetime(2008, 1, 31),
                       datetime(2008, 2, 7): datetime(2008, 2, 29)}))

        for offset, cases in tests:
            for base, expected in compat.iteritems(cases):
                assertEq(offset, base, expected)

    def test_apply_large_n(self):
        dt = datetime(2012, 10, 23)

        result = dt + CBMonthEnd(10)
        self.assertEqual(result, datetime(2013, 7, 31))

        result = dt + CDay(100) - CDay(100)
        self.assertEqual(result, dt)

        off = CBMonthEnd() * 6
        rs = datetime(2012, 1, 1) - off
        xp = datetime(2011, 7, 29)
        self.assertEqual(rs, xp)

        st = datetime(2011, 12, 18)
        rs = st + off
        xp = datetime(2012, 5, 31)
        self.assertEqual(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)
        self.assertEqual(dt + bm_offset,datetime(2012,1,30))
        self.assertEqual(dt + 2*bm_offset,datetime(2012,2,27))

    def test_datetimeindex(self):
        from pandas.tseries.holiday import USFederalHolidayCalendar
        self.assertEqual(DatetimeIndex(start='20120101',end='20130101',freq=CBMonthEnd(calendar=USFederalHolidayCalendar())).tolist()[0],
        datetime(2012,1,31))

class TestCustomBusinessMonthBegin(CustomBusinessMonthBase, Base):
    _object = CBMonthBegin

    def test_different_normalize_equals(self):
        # equivalent in this special case
        offset = CBMonthBegin()
        offset2 = CBMonthBegin()
        offset2.normalize = True
        self.assertEqual(offset, offset2)

    def test_repr(self):
        assert repr(self.offset) == '<CustomBusinessMonthBegin>'
        assert repr(self.offset2) == '<2 * CustomBusinessMonthBegins>'

    def testCall(self):
        self.assertEqual(self.offset2(self.d), datetime(2008, 3, 3))

    def testRollback1(self):
        self.assertEqual(
            CDay(10).rollback(datetime(2007, 12, 31)), datetime(2007, 12, 31))

    def testRollback2(self):
        self.assertEqual(CBMonthBegin(10).rollback(self.d),
                         datetime(2008,1,1))

    def testRollforward1(self):
        self.assertEqual(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)
        self.assertEqual(result, datetime(2012, 9, 3))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 10, 1))

        offset = offsets.Day()
        result = offset.rollback(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2012, 9, 15))

    def test_onOffset(self):
        tests = [(CBMonthBegin(), datetime(2008, 1, 1), True),
                 (CBMonthBegin(), datetime(2008, 1, 31), False)]

        for offset, date, expected in tests:
            assertOnOffset(offset, date, expected)


    def test_apply(self):
        cbm = CBMonthBegin()
        tests = []

        tests.append((cbm,
                      {datetime(2008, 1, 1): datetime(2008, 2, 1),
                       datetime(2008, 2, 7): datetime(2008, 3, 3)}))

        tests.append((2 * cbm,
                      {datetime(2008, 1, 1): datetime(2008, 3, 3),
                       datetime(2008, 2, 7): datetime(2008, 4, 1)}))

        tests.append((-cbm,
                      {datetime(2008, 1, 1): datetime(2007, 12, 3),
                       datetime(2008, 2, 8): datetime(2008, 2, 1)}))

        tests.append((-2 * cbm,
                      {datetime(2008, 1, 1): datetime(2007, 11, 1),
                       datetime(2008, 2, 9): datetime(2008, 1, 1)}))

        tests.append((CBMonthBegin(0),
                      {datetime(2008, 1, 1): datetime(2008, 1, 1),
                       datetime(2008, 1, 7): datetime(2008, 2, 1)}))

        for offset, cases in tests:
            for base, expected in compat.iteritems(cases):
                assertEq(offset, base, expected)

    def test_apply_large_n(self):
        dt = datetime(2012, 10, 23)

        result = dt + CBMonthBegin(10)
        self.assertEqual(result, datetime(2013, 8, 1))

        result = dt + CDay(100) - CDay(100)
        self.assertEqual(result, dt)

        off = CBMonthBegin() * 6
        rs = datetime(2012, 1, 1) - off
        xp = datetime(2011, 7, 1)
        self.assertEqual(rs, xp)

        st = datetime(2011, 12, 18)
        rs = st + off
        xp = datetime(2012, 6, 1)
        self.assertEqual(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)
        self.assertEqual(dt + bm_offset,datetime(2012,1,2))
        self.assertEqual(dt + 2*bm_offset,datetime(2012,2,3))

    def test_datetimeindex(self):
        self.assertEqual(DatetimeIndex(start='20120101',end='20130101',freq=CBMonthBegin(calendar=USFederalHolidayCalendar())).tolist()[0],
        datetime(2012,1,3))


def assertOnOffset(offset, date, expected):
    actual = offset.onOffset(date)
    assert actual == expected, ("\nExpected: %s\nActual: %s\nFor Offset: %s)"
                                "\nAt Date: %s" %
                                (expected, actual, offset, date))


class TestWeek(Base):
    _offset = Week

    def test_repr(self):
        self.assertEqual(repr(Week(weekday=0)), "<Week: weekday=0>")
        self.assertEqual(repr(Week(n=-1, weekday=0)), "<-1 * Week: weekday=0>")
        self.assertEqual(repr(Week(n=-2, weekday=0)), "<-2 * Weeks: weekday=0>")

    def test_corner(self):
        self.assertRaises(ValueError, Week, weekday=7)
        assertRaisesRegexp(ValueError, "Day must be", Week, weekday=-1)

    def test_isAnchored(self):
        self.assertTrue(Week(weekday=0).isAnchored())
        self.assertFalse(Week().isAnchored())
        self.assertFalse(Week(2, weekday=2).isAnchored())
        self.assertFalse(Week(2).isAnchored())

    def test_offset(self):
        tests = []

        tests.append((Week(),  # not business week
                      {datetime(2008, 1, 1): datetime(2008, 1, 8),
                       datetime(2008, 1, 4): datetime(2008, 1, 11),
                       datetime(2008, 1, 5): datetime(2008, 1, 12),
                       datetime(2008, 1, 6): datetime(2008, 1, 13),
                       datetime(2008, 1, 7): datetime(2008, 1, 14)}))

        tests.append((Week(weekday=0),  # Mon
                      {datetime(2007, 12, 31): datetime(2008, 1, 7),
                       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, 14)}))

        tests.append((Week(0, weekday=0),  # n=0 -> roll forward. Mon
                      {datetime(2007, 12, 31): datetime(2007, 12, 31),
                       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, 7)}))

        tests.append((Week(-2, weekday=1),  # n=0 -> roll forward. Mon
                      {datetime(2010, 4, 6): datetime(2010, 3, 23),
                       datetime(2010, 4, 8): datetime(2010, 3, 30),
                       datetime(2010, 4, 5): datetime(2010, 3, 23)}))

        for offset, cases in tests:
            for base, expected in compat.iteritems(cases):
                assertEq(offset, base, expected)

    def test_onOffset(self):
        for weekday in range(7):
            offset = Week(weekday=weekday)

            for day in range(1, 8):
                date = datetime(2008, 1, day)

                if day % 7 == weekday:
                    expected = True
                else:
                    expected = False
            assertOnOffset(offset, date, expected)

    def test_offsets_compare_equal(self):
        # root cause of #456
        offset1 = Week()
        offset2 = Week()
        self.assertFalse(offset1 != offset2)


class TestWeekOfMonth(Base):
    _offset = WeekOfMonth

    def test_constructor(self):
        assertRaisesRegexp(ValueError, "^N cannot be 0", WeekOfMonth, n=0, week=1, weekday=1)
        assertRaisesRegexp(ValueError, "^Week", WeekOfMonth, n=1, week=4, weekday=0)
        assertRaisesRegexp(ValueError, "^Week", WeekOfMonth, n=1, week=-1, weekday=0)
        assertRaisesRegexp(ValueError, "^Day", WeekOfMonth, n=1, week=0, weekday=-1)
        assertRaisesRegexp(ValueError, "^Day", WeekOfMonth, n=1, week=0, weekday=7)

    def test_repr(self):
        self.assertEqual(repr(WeekOfMonth(weekday=1,week=2)), "<WeekOfMonth: week=2, weekday=1>")

    def test_offset(self):
        date1 = datetime(2011, 1, 4)  # 1st Tuesday of Month
        date2 = datetime(2011, 1, 11)  # 2nd Tuesday of Month
        date3 = datetime(2011, 1, 18)  # 3rd Tuesday of Month
        date4 = datetime(2011, 1, 25)  # 4th Tuesday of Month

        # see for loop for structure
        test_cases = [
            (-2, 2, 1, date1, datetime(2010, 11, 16)),
            (-2, 2, 1, date2, datetime(2010, 11, 16)),
            (-2, 2, 1, date3, datetime(2010, 11, 16)),
            (-2, 2, 1, date4, datetime(2010, 12, 21)),

            (-1, 2, 1, date1, datetime(2010, 12, 21)),
            (-1, 2, 1, date2, datetime(2010, 12, 21)),
            (-1, 2, 1, date3, datetime(2010, 12, 21)),
            (-1, 2, 1, date4, datetime(2011, 1, 18)),

            (1, 0, 0, date1, datetime(2011, 2, 7)),
            (1, 0, 0, date2, datetime(2011, 2, 7)),
            (1, 0, 0, date3, datetime(2011, 2, 7)),
            (1, 0, 0, date4, datetime(2011, 2, 7)),
            (1, 0, 1, date1, datetime(2011, 2, 1)),
            (1, 0, 1, date2, datetime(2011, 2, 1)),
            (1, 0, 1, date3, datetime(2011, 2, 1)),
            (1, 0, 1, date4, datetime(2011, 2, 1)),
            (1, 0, 2, date1, datetime(2011, 1, 5)),
            (1, 0, 2, date2, datetime(2011, 2, 2)),
            (1, 0, 2, date3, datetime(2011, 2, 2)),
            (1, 0, 2, date4, datetime(2011, 2, 2)),

            (1, 2, 1, date1, datetime(2011, 1, 18)),
            (1, 2, 1, date2, datetime(2011, 1, 18)),
            (1, 2, 1, date3, datetime(2011, 2, 15)),
            (1, 2, 1, date4, datetime(2011, 2, 15)),

            (2, 2, 1, date1, datetime(2011, 2, 15)),
            (2, 2, 1, date2, datetime(2011, 2, 15)),
            (2, 2, 1, date3, datetime(2011, 3, 15)),
            (2, 2, 1, date4, datetime(2011, 3, 15)),
        ]

        for n, week, weekday, date, expected in test_cases:
            offset = WeekOfMonth(n, week=week, weekday=weekday)
            assertEq(offset, date, expected)

        # try subtracting
        result = datetime(2011, 2, 1) - WeekOfMonth(week=1, weekday=2)
        self.assertEqual(result, datetime(2011, 1, 12))
        result = datetime(2011, 2, 3) - WeekOfMonth(week=0, weekday=2)
        self.assertEqual(result, datetime(2011, 2, 2))

    def test_onOffset(self):
        test_cases = [
            (0, 0, datetime(2011, 2, 7), True),
            (0, 0, datetime(2011, 2, 6), False),
            (0, 0, datetime(2011, 2, 14), False),
            (1, 0, datetime(2011, 2, 14), True),
            (0, 1, datetime(2011, 2, 1), True),
            (0, 1, datetime(2011, 2, 8), False),
        ]

        for week, weekday, date, expected in test_cases:
            offset = WeekOfMonth(week=week, weekday=weekday)
            self.assertEqual(offset.onOffset(date), expected)

class TestLastWeekOfMonth(Base):
    _offset = LastWeekOfMonth

    def test_constructor(self):
        assertRaisesRegexp(ValueError, "^N cannot be 0", \
                           LastWeekOfMonth, n=0, weekday=1)

        assertRaisesRegexp(ValueError, "^Day", LastWeekOfMonth, n=1, weekday=-1)
        assertRaisesRegexp(ValueError, "^Day", LastWeekOfMonth, n=1, weekday=7)

    def test_offset(self):
        #### Saturday
        last_sat = datetime(2013,8,31)
        next_sat = datetime(2013,9,28)
        offset_sat = LastWeekOfMonth(n=1, weekday=5)

        one_day_before = (last_sat + timedelta(days=-1))
        self.assertEqual(one_day_before + offset_sat, last_sat)

        one_day_after = (last_sat + timedelta(days=+1))
        self.assertEqual(one_day_after + offset_sat, next_sat)

        #Test On that day
        self.assertEqual(last_sat + offset_sat, next_sat)

        #### Thursday

        offset_thur = LastWeekOfMonth(n=1, weekday=3)
        last_thurs = datetime(2013,1,31)
        next_thurs = datetime(2013,2,28)

        one_day_before = last_thurs + timedelta(days=-1)
        self.assertEqual(one_day_before + offset_thur, last_thurs)

        one_day_after = last_thurs + timedelta(days=+1)
        self.assertEqual(one_day_after + offset_thur, next_thurs)

        # Test on that day
        self.assertEqual(last_thurs + offset_thur, next_thurs)

        three_before = last_thurs + timedelta(days=-3)
        self.assertEqual(three_before + offset_thur, last_thurs)

        two_after = last_thurs + timedelta(days=+2)
        self.assertEqual(two_after + offset_thur, next_thurs)

        offset_sunday = LastWeekOfMonth(n=1, weekday=WeekDay.SUN)
        self.assertEqual(datetime(2013,7,31) + offset_sunday, datetime(2013,8,25))

    def test_onOffset(self):
        test_cases = [
            (WeekDay.SUN, datetime(2013, 1, 27), True),
            (WeekDay.SAT, datetime(2013, 3, 30), True),
            (WeekDay.MON, datetime(2013, 2, 18), False), #Not the last Mon
            (WeekDay.SUN, datetime(2013, 2, 25), False), #Not a SUN
            (WeekDay.MON, datetime(2013, 2, 25), True),
            (WeekDay.SAT, datetime(2013, 11, 30), True),

            (WeekDay.SAT, datetime(2006, 8, 26), True),
            (WeekDay.SAT, datetime(2007, 8, 25), True),
            (WeekDay.SAT, datetime(20…