/pandas/tseries/tests/test_offsets.py

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

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

import numpy as np

from pandas.compat.numpy import np_datetime64_compat
from pandas.core.datetools import (bday, BDay, CDay, BQuarterEnd, BMonthEnd,
                                   BusinessHour, CustomBusinessHour,
                                   CBMonthEnd, CBMonthBegin, BYearEnd,
                                   MonthEnd, MonthBegin, SemiMonthBegin,
                                   SemiMonthEnd, 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_standard_freq)

from pandas.core.series import Series
from pandas.tseries.frequencies import (_offset_map, get_freq_code,
                                        _get_freq_str, _INVALID_FREQ_ERROR)
from pandas.tseries.index import _to_m8, DatetimeIndex, _daterange_cache
from pandas.tseries.tools import parse_time_string, DateParseError
import pandas.tseries.offsets as offsets
from pandas.io.pickle import read_pickle
from pandas.tslib import NaT, Timestamp, Timedelta
import pandas.tslib as tslib
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

_multiprocess_can_split_ = True


def test_monthrange():
    import calendar
    for y in range(2000, 2013):
        for m in range(1, 13):
            assert tslib.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, errors='ignore') == 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.assertIsInstance(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__]

    timezones = [None, 'UTC', 'Asia/Tokyo', 'US/Eastern',
                 'dateutil/Asia/Tokyo', 'dateutil/US/Pacific']

    @property
    def offset_types(self):
        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)
        elif klass is DateOffset:
            klass = klass(days=value, 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

        # try to create an out-of-bounds result timestamp; if we can't create
        # the offset skip
        try:
            if self._offset in (BusinessHour, CustomBusinessHour):
                # Using 10000 in BusinessHour fails in tz check because of DST
                # difference
                offset = self._get_offset(self._offset, value=100000)
            else:
                offset = self._get_offset(self._offset, value=10000)

            result = Timestamp('20080101') + offset
            self.assertIsInstance(result, datetime)
            self.assertIsNone(result.tzinfo)

            tm._skip_if_no_pytz()
            tm._skip_if_no_dateutil()
            # Check tz is preserved
            for tz in self.timezones:
                t = Timestamp('20080101', tz=tz)
                result = t + offset
                self.assertIsInstance(result, datetime)
                self.assertEqual(t.tzinfo, result.tzinfo)

        except (tslib.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'),
                          '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(np_datetime64_compat(
                              '2011-01-01T09:00:00.000000001Z'))}

    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 test_offset_n(self):
        for offset_klass in self.offset_types:
            offset = self._get_offset(offset_klass)
            self.assertEqual(offset.n, 1)

            neg_offset = offset * -1
            self.assertEqual(neg_offset.n, -1)

            mul_offset = offset * 3
            self.assertEqual(mul_offset.n, 3)

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

            freqstr = offset.freqstr
            if freqstr not in ('<Easter>',
                               "<DateOffset: kwds={'days': 1}>",
                               'LWOM-SAT', ):
                code = get_offset(freqstr)
                self.assertEqual(offset.rule_code, code)

    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.assertTrue(isinstance(result, Timestamp))
        self.assertEqual(result, expected)

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

        # test nano second is preserved
        result = func(Timestamp(dt) + Nano(5))
        self.assertTrue(isinstance(result, Timestamp))
        if normalize is False:
            self.assertEqual(result, expected + Nano(5))
        else:
            self.assertEqual(result, expected)

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

        tm._skip_if_no_pytz()
        tm._skip_if_no_dateutil()

        for tz in self.timezones:
            expected_localize = expected.tz_localize(tz)
            tz_obj = tslib.maybe_get_tz(tz)
            dt_tz = tslib._localize_pydatetime(dt, tz_obj)

            result = func(dt_tz)
            self.assertTrue(isinstance(result, Timestamp))
            self.assertEqual(result, expected_localize)

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

            # test nano second is preserved
            result = func(Timestamp(dt, tz=tz) + Nano(5))
            self.assertTrue(isinstance(result, Timestamp))
            if normalize is False:
                self.assertEqual(result, expected_localize + Nano(5))
            else:
                self.assertEqual(result, expected_localize)

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

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = self.expecteds[offset.__name__]
                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', '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_compat('2011-01-01 09:00Z')

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = expecteds[offset.__name__]
                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'),
                     '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_compat('2011-01-01 09:00Z')

        for offset in self.offset_types:
            for dt in [sdt, ndt]:
                expected = expecteds[offset.__name__]
                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.assertTrue(offset_s.onOffset(dt))

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

            if offset in (BusinessHour, CustomBusinessHour):
                # In default BusinessHour (9:00-17:00), normalized time
                # cannot be in business hour range
                continue
            date = datetime(dt.year, dt.month, dt.day)
            self.assertTrue(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.assertTrue(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.assertTrue(isinstance(result, Timestamp))
                self.assertEqual(result, expected_localize)

    def test_pickle_v0_15_2(self):
        offsets = {'DateOffset': DateOffset(years=1),
                   'MonthBegin': MonthBegin(1),
                   'Day': Day(1),
                   'YearBegin': YearBegin(1),
                   'Week': Week(1)}
        pickle_path = os.path.join(tm.get_data_path(),
                                   'dateoffset_0_15_2.pickle')
        # This code was executed once on v0.15.2 to generate the pickle:
        # with open(pickle_path, 'wb') as f: pickle.dump(offsets, f)
        #
        tm.assert_dict_equal(offsets, read_pickle(pickle_path))


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, d, expected in tests:
            assertOnOffset(offset, d, 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 TestBusinessHour(Base):
    _multiprocess_can_split_ = True
    _offset = BusinessHour

    def setUp(self):
        self.d = datetime(2014, 7, 1, 10, 00)

        self.offset1 = BusinessHour()
        self.offset2 = BusinessHour(n=3)

        self.offset3 = BusinessHour(n=-1)
        self.offset4 = BusinessHour(n=-4)

        from datetime import time as dt_time
        self.offset5 = BusinessHour(start=dt_time(11, 0), end=dt_time(14, 30))
        self.offset6 = BusinessHour(start='20:00', end='05:00')
        self.offset7 = BusinessHour(n=-2, start=dt_time(21, 30),
                                    end=dt_time(6, 30))

    def test_constructor_errors(self):
        from datetime import time as dt_time
        with tm.assertRaises(ValueError):
            BusinessHour(start=dt_time(11, 0, 5))
        with tm.assertRaises(ValueError):
            BusinessHour(start='AAA')
        with tm.assertRaises(ValueError):
            BusinessHour(start='14:00:05')

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

    def test_repr(self):
        self.assertEqual(repr(self.offset1), '<BusinessHour: BH=09:00-17:00>')
        self.assertEqual(repr(self.offset2),
                         '<3 * BusinessHours: BH=09:00-17:00>')
        self.assertEqual(repr(self.offset3),
                         '<-1 * BusinessHour: BH=09:00-17:00>')
        self.assertEqual(repr(self.offset4),
                         '<-4 * BusinessHours: BH=09:00-17:00>')

        self.assertEqual(repr(self.offset5), '<BusinessHour: BH=11:00-14:30>')
        self.assertEqual(repr(self.offset6), '<BusinessHour: BH=20:00-05:00>')
        self.assertEqual(repr(self.offset7),
                         '<-2 * BusinessHours: BH=21:30-06:30>')

    def test_with_offset(self):
        expected = Timestamp('2014-07-01 13:00')

        self.assertEqual(self.d + BusinessHour() * 3, expected)
        self.assertEqual(self.d + BusinessHour(n=3), expected)

    def testEQ(self):
        for offset in [self.offset1, self.offset2, self.offset3, self.offset4]:
            self.assertEqual(offset, offset)

        self.assertNotEqual(BusinessHour(), BusinessHour(-1))
        self.assertEqual(BusinessHour(start='09:00'), BusinessHour())
        self.assertNotEqual(BusinessHour(start='09:00'),
                            BusinessHour(start='09:01'))
        self.assertNotEqual(BusinessHour(start='09:00', end='17:00'),
                            BusinessHour(start='17:00', end='09:01'))

    def test_hash(self):
        for offset in [self.offset1, self.offset2, self.offset3, self.offset4]:
            self.assertEqual(hash(offset), hash(offset))

    def testCall(self):
        self.assertEqual(self.offset1(self.d), datetime(2014, 7, 1, 11))
        self.assertEqual(self.offset2(self.d), datetime(2014, 7, 1, 13))
        self.assertEqual(self.offset3(self.d), datetime(2014, 6, 30, 17))
        self.assertEqual(self.offset4(self.d), datetime(2014, 6, 30, 14))

    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._offset(-3))

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

    def testMult1(self):
        self.assertEqual(self.d + 5 * self.offset1, self.d + self._offset(5))

    def testMult2(self):
        self.assertEqual(self.d + (-3 * self._offset(-2)),
                         self.d + self._offset(6))

    def testRollback1(self):
        self.assertEqual(self.offset1.rollback(self.d), self.d)
        self.assertEqual(self.offset2.rollback(self.d), self.d)
        self.assertEqual(self.offset3.rollback(self.d), self.d)
        self.assertEqual(self.offset4.rollback(self.d), self.d)
        self.assertEqual(self.offset5.rollback(self.d),
                         datetime(2014, 6, 30, 14, 30))
        self.assertEqual(self.offset6.rollback(
            self.d), datetime(2014, 7, 1, 5, 0))
        self.assertEqual(self.offset7.rollback(
            self.d), datetime(2014, 7, 1, 6, 30))

        d = datetime(2014, 7, 1, 0)
        self.assertEqual(self.offset1.rollback(d), datetime(2014, 6, 30, 17))
        self.assertEqual(self.offset2.rollback(d), datetime(2014, 6, 30, 17))
        self.assertEqual(self.offset3.rollback(d), datetime(2014, 6, 30, 17))
        self.assertEqual(self.offset4.rollback(d), datetime(2014, 6, 30, 17))
        self.assertEqual(self.offset5.rollback(
            d), datetime(2014, 6, 30, 14, 30))
        self.assertEqual(self.offset6.rollback(d), d)
        self.assertEqual(self.offset7.rollback(d), d)

        self.assertEqual(self._offset(5).rollback(self.d), self.d)

    def testRollback2(self):
        self.assertEqual(self._offset(-3)
                         .rollback(datetime(2014, 7, 5, 15, 0)),
                         datetime(2014, 7, 4, 17, 0))

    def testRollforward1(self):
        self.assertEqual(self.offset1.rollforward(self.d), self.d)
        self.assertEqual(self.offset2.rollforward(self.d), self.d)
        self.assertEqual(self.offset3.rollforward(self.d), self.d)
        self.assertEqual(self.offset4.rollforward(self.d), self.d)
        self.assertEqual(self.offset5.rollforward(
            self.d), datetime(2014, 7, 1, 11, 0))
        self.assertEqual(self.offset6.rollforward(
            self.d), datetime(2014, 7, 1, 20, 0))
        self.assertEqual(self.offset7.rollforward(
            self.d), datetime(2014, 7, 1, 21, 30))

        d = datetime(2014, 7, 1, 0)
        self.assertEqual(self.offset1.rollforward(d), datetime(2014, 7, 1, 9))
        self.assertEqual(self.offset2.rollforward(d), datetime(2014, 7, 1, 9))
        self.assertEqual(self.offset3.rollforward(d), datetime(2014, 7, 1, 9))
        self.assertEqual(self.offset4.rollforward(d), datetime(2014, 7, 1, 9))
        self.assertEqual(self.offset5.rollforward(d), datetime(2014, 7, 1, 11))
        self.assertEqual(self.offset6.rollforward(d), d)
        self.assertEqual(self.offset7.rollforward(d), d)

        self.assertEqual(self._offset(5).rollforward(self.d), self.d)

    def testRollforward2(self):
        self.assertEqual(self._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)
        self.assertEqual(result, datetime(2014, 7, 4, 17))

        result = offset.rollforward(dt)
        self.assertEqual(result, datetime(2014, 7, 7, 9))

    def test_normalize(self):
        tests = []

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

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

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

        for offset, cases in tests:
            for dt, expected in compat.iteritems(cases):
                self.assertEqual(offset.apply(dt), expected)

    def test_onOffset(self):
        tests = []

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

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

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

        for offset, cases in tests:
            for dt, expected in compat.iteritems(cases):
                self.assertEqual(offset.onOffset(dt), expected)

    def test_opening_time(self):
        tests = []

        # opening time should be affected by sign of n, not by n's value and
        # end
        tests.append((
            [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))}))

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

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

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

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

        for _offsets, cases in tests:
            for offset in _offsets:
                for dt, (exp_next, exp_prev) in compat.iteritems(cases):
                    self.assertEqual(offset._next_opening_time(dt), exp_next)
                    self.assertEqual(offset._prev_opening_time(dt), exp_prev)

    def test_apply(self):
        tests = []

     …