예제 #1
0
    def test_040_registered_attribute_simple_class(self, clean_Date):
        Date.register_new_calendar('test_1', ExampleTestCalendar)

        # Date attribute type and metaclass are correct
        assert Date.test_1.__name__ == 'ExampleTestCalendarInDate'
        assert type(Date.test_1).__name__ == 'ModifiedClass'
        assert issubclass(Date.test_1, ExampleTestCalendar)

        # constructed date type and value are is correct
        d1a = Date.test_1(100, 4)
        assert type(d1a) == Date
        assert d1a.day_count == 697

        # new attribute on date instance, type and value are correct
        d1b = Date(1000)
        assert isinstance(d1b.test_1, ExampleTestCalendar)
        assert type(d1b.test_1).__name__ == 'ExampleTestCalendarInDate'
        assert type(d1b.test_1.__class__).__name__ == 'ModifiedClass'
        assert d1b.test_1.week == 143
        assert d1b.test_1.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d1c = Date.gregorian(100, 2, 3)
        assert isinstance(d1c.test_1, ExampleTestCalendar)
        assert type(d1c.test_1).__name__ == 'ExampleTestCalendarInDate'
        assert type(d1c.test_1.__class__).__name__ == 'ModifiedClass'
        assert d1c.test_1.week == 5171
        assert d1c.test_1.day == 3
예제 #2
0
    def test_040_registered_attribute_simple_class(self, clean_Date):
        Date.register_new_calendar("test_1", ExampleTestCalendar)

        # Date attribute type and metaclass are correct
        assert Date.test_1.__name__ == "ExampleTestCalendarInDate"
        assert type(Date.test_1).__name__ == "ModifiedClass"
        assert issubclass(Date.test_1, ExampleTestCalendar)

        # constructed date type and value are is correct
        d1a = Date.test_1(100, 4)
        assert type(d1a) == Date
        assert d1a.day_count == 697

        # new attribute on date instance, type and value are correct
        d1b = Date(1000)
        assert isinstance(d1b.test_1, ExampleTestCalendar)
        assert type(d1b.test_1).__name__ == "ExampleTestCalendarInDate"
        assert type(d1b.test_1.__class__).__name__ == "ModifiedClass"
        assert d1b.test_1.week == 143
        assert d1b.test_1.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d1c = Date.gregorian(100, 2, 3)
        assert isinstance(d1c.test_1, ExampleTestCalendar)
        assert type(d1c.test_1).__name__ == "ExampleTestCalendarInDate"
        assert type(d1c.test_1.__class__).__name__ == "ModifiedClass"
        assert d1c.test_1.week == 5171
        assert d1c.test_1.day == 3
예제 #3
0
 def test_000_register_new_calendar(self, clean_Date):
     assert not hasattr(Date, "test_1")
     with pytest.raises(AttributeError):
         Date.test_1
     Date.register_new_calendar("test_1", ExampleTestCalendar)
     assert hasattr(Date, "test_1")
     Date.test_1
예제 #4
0
 def test_000_register_new_calendar(self, clean_Date):
     assert not hasattr(Date, 'test_1')
     with pytest.raises(AttributeError):
         Date.test_1
     Date.register_new_calendar('test_1', ExampleTestCalendar)
     assert hasattr(Date, 'test_1')
     Date.test_1
예제 #5
0
    def test_310_disallowed_operations(self):
        a = Date(42)
        b = Date(24)

        # These operations are invalid because TimeDelta is not integer.
        for value in (42.25, 41.75, -42.25, -41.75):
            with pytest.raises(ValueError):
                a + TimeDelta(value)
            with pytest.raises(ValueError):
                a - TimeDelta(value)

        # Add/sub int, float, string, complex, specials and containers should be illegal
        for obj in (10, 34.5, "abc", 1 + 2j, INF, NAN, {}, [], ()):
            with pytest.raises(TypeError):
                a + obj
            with pytest.raises(TypeError):
                a - obj
            with pytest.raises(TypeError):
                obj + a
            with pytest.raises(TypeError):
                obj - a

        # Reverse operations
        with pytest.raises(TypeError):
            TimeDelta(2) - a

        for obj in (1, 1.1, b):
            with pytest.raises(TypeError):
                a * obj
            with pytest.raises(TypeError):
                obj * a
            with pytest.raises(TypeError):
                a / obj
            with pytest.raises(TypeError):
                obj / a
            with pytest.raises(TypeError):
                a // obj
            with pytest.raises(TypeError):
                obj // a
            with pytest.raises(TypeError):
                pow(a, obj)
            with pytest.raises(TypeError):
                pow(obj, a)
            with pytest.raises(TypeError):
                a ^ obj
            with pytest.raises(TypeError):
                obj ^ a
            with pytest.raises(TypeError):
                a >> obj
            with pytest.raises(TypeError):
                obj >> a
            with pytest.raises(TypeError):
                a << obj
            with pytest.raises(TypeError):
                obj << a
예제 #6
0
 def test_010_invalid_parameter_types(self):
     """The argument is required and must be an integer."""
     # exception with no or two parameters
     with pytest.raises(TypeError):
         Date()
     with pytest.raises(TypeError):
         Date(1, 2)
     # exception with non-numeric types
     for par in ("1", (1,), [1], {1: 1}, (), [], {}, None):
         with pytest.raises(TypeError):
             Date(par)
     # exception with invalid numeric types
     for par in (1.0, Fraction(1, 1), Decimal(1), 1j):
         with pytest.raises(TypeError):
             Date(par)
예제 #7
0
 def test_900_pickling(self):
     for day_count in date_test_data:
         d = Date(day_count)
         for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
             pickled = pickle.dumps(d, protocol)
             derived = pickle.loads(pickled)
             assert d == derived
예제 #8
0
    def test_330_comparison_with_invalid_types(self):
        class SomeClass:
            pass

        d = Date(1)

        # exception with non-numeric types
        for par in ("1", (1,), [1], {1: 1}, (), [], {}, None, SomeClass()):
            assert not (d == par)
            assert d != par
            with pytest.raises(TypeError):
                d < par
            with pytest.raises(TypeError):
                d > par
            with pytest.raises(TypeError):
                d <= par
            with pytest.raises(TypeError):
                d >= par

        # exception with numeric types (all invalid)
        for par in (1, 1.0, Fraction(1, 1), Decimal(1), 1j, 1 + 1j, INF, NAN):
            assert not (d == par)
            assert d != par
            with pytest.raises(TypeError):
                d < par
            with pytest.raises(TypeError):
                d > par
            with pytest.raises(TypeError):
                d <= par
            with pytest.raises(TypeError):
                d >= par
예제 #9
0
 def test_900_avoid_date_override(self):
     d = Date.gregorian(1, 1, 1)
     # I do not want an instance of Date created through a Gregorian to have its static methods
     # One of the implementation I used had this error and I want to avoid it
     with pytest.raises(AttributeError):
         getattr(d, 'is_leap_year')
     with pytest.raises(AttributeError):
         d.is_leap_year
예제 #10
0
 def test_900_avoid_date_override(self):
     d = Date.gregorian(1, 1, 1)
     # I do not want an instance of Date created through a Gregorian to have its static methods
     # One of the implementation I used had this error and I want to avoid it
     with pytest.raises(AttributeError):
         getattr(d, "is_leap_year")
     with pytest.raises(AttributeError):
         d.is_leap_year
예제 #11
0
    def test_340_hash_equality(self):
        """Date instances are immutable."""
        d1 = Date(42)
        d2 = Date(42)
        assert hash(d1) == hash(d2)

        dic = {d1: 1}
        dic[d2] = 2
        assert len(dic) == 1
        assert dic[d1] == 2
        assert dic[d2] == 2

        d3 = Date(32) + TimeDelta(10)
        assert hash(d1) == hash(d3)

        dic[d3] = 2
        assert len(dic) == 1
        assert dic[d3] == 2
예제 #12
0
 def test_110_get_unknown_attribute(self):
     """Date instances have one attribute."""
     # I want to do this, because Date will have attributes added at runtime
     # let's tests this both on class and instance
     with pytest.raises(AttributeError):
         Date.unknown
     d = Date(1)
     with pytest.raises(AttributeError):
         d.unknown
예제 #13
0
    def test_046_registered_attribute_class_with_static_methods(
            self, clean_Date):
        class ExampleTestCalendar3(ExampleTestCalendar):
            @staticmethod
            def is_odd(number):
                return (number % 2) == 1

        Date.register_new_calendar("test_3", ExampleTestCalendar3)

        # Date attribute type and metaclass are correct
        assert Date.test_3.__name__ == "ExampleTestCalendar3InDate"
        assert type(Date.test_3).__name__ == "ModifiedClass"
        assert issubclass(Date.test_3, ExampleTestCalendar)

        # constructed date type and value are is correct
        d3a = Date.test_3(100, 4)
        assert type(d3a) == Date
        assert d3a.day_count == 697

        # new attribute on date instance, type and value are correct
        d3b = Date(1000)
        assert isinstance(d3b.test_3, ExampleTestCalendar3)
        assert type(d3b.test_3).__name__ == "ExampleTestCalendar3InDate"
        assert type(d3b.test_3.__class__).__name__ == "ModifiedClass"
        assert d3b.test_3.week == 143
        assert d3b.test_3.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d3c = Date.gregorian(100, 2, 3)
        assert isinstance(d3c.test_3, ExampleTestCalendar3)
        assert type(d3c.test_3).__name__ == "ExampleTestCalendar3InDate"
        assert type(d3c.test_3.__class__).__name__ == "ModifiedClass"
        assert d3c.test_3.week == 5171
        assert d3c.test_3.day == 3

        # static method can be reached on the class and on all types of instance
        assert Date.test_3.is_odd(3)
        assert not Date.test_3.is_odd(4)
        assert d3a.test_3.is_odd(3)
        assert not d3a.test_3.is_odd(4)
        assert d3b.test_3.is_odd(3)
        assert not d3b.test_3.is_odd(4)
        assert d3c.test_3.is_odd(3)
        assert not d3c.test_3.is_odd(4)
예제 #14
0
    def test_046_registered_attribute_class_with_static_methods(self, clean_Date):
        class ExampleTestCalendar3(ExampleTestCalendar):
            @staticmethod
            def is_odd(number):
                return (number % 2) == 1

        Date.register_new_calendar('test_3', ExampleTestCalendar3)

        # Date attribute type and metaclass are correct
        assert Date.test_3.__name__ == 'ExampleTestCalendar3InDate'
        assert type(Date.test_3).__name__ == 'ModifiedClass'
        assert issubclass(Date.test_3, ExampleTestCalendar)

        # constructed date type and value are is correct
        d3a = Date.test_3(100, 4)
        assert type(d3a) == Date
        assert d3a.day_count == 697

        # new attribute on date instance, type and value are correct
        d3b = Date(1000)
        assert isinstance(d3b.test_3, ExampleTestCalendar3)
        assert type(d3b.test_3).__name__ == 'ExampleTestCalendar3InDate'
        assert type(d3b.test_3.__class__).__name__ == 'ModifiedClass'
        assert d3b.test_3.week == 143
        assert d3b.test_3.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d3c = Date.gregorian(100, 2, 3)
        assert isinstance(d3c.test_3, ExampleTestCalendar3)
        assert type(d3c.test_3).__name__ == 'ExampleTestCalendar3InDate'
        assert type(d3c.test_3.__class__).__name__ == 'ModifiedClass'
        assert d3c.test_3.week == 5171
        assert d3c.test_3.day == 3

        # static method can be reached on the class and on all types of instance
        assert Date.test_3.is_odd(3)
        assert not Date.test_3.is_odd(4)
        assert d3a.test_3.is_odd(3)
        assert not d3a.test_3.is_odd(4)
        assert d3b.test_3.is_odd(3)
        assert not d3b.test_3.is_odd(4)
        assert d3c.test_3.is_odd(3)
        assert not d3c.test_3.is_odd(4)
예제 #15
0
    def test_500_repr(self):
        import datetime2

        for day_count in date_test_data:
            d = Date(day_count)
            date_repr = repr(d)
            names, args = date_repr.split("(")
            assert names.split(".") == ["datetime2", "Date"]
            args = args[:-1]  # drop ')'
            assert int(args) == day_count
            assert d == eval(repr(d))
예제 #16
0
 def test_100_date_has_attributes_but_instance_not(self):
     # the date class aways has a registered attribute
     assert hasattr(Date, 'gregorian')
     assert Date.gregorian
     # an instance created with another calendar or by Date does not have
     #   the attribute; it is instead is reachable via the Date class
     d1 = Date(4)
     with pytest.raises(KeyError):
         d1.__dict__['gregorian']
     assert hasattr(d1, 'gregorian')
     d1.gregorian
     d2 = Date.iso(3, 4, 5)
     with pytest.raises(KeyError):
         d2.__dict__['gregorian']
     assert hasattr(d2, 'gregorian')
     d2.gregorian
     # a Date instance created via the calendar does have the same attribute
     d3 = Date.gregorian(3, 4, 5)
     assert hasattr(d3, 'gregorian')
     d3.gregorian
예제 #17
0
 def test_100_date_has_attributes_but_instance_not(self):
     # the date class aways has a registered attribute
     assert hasattr(Date, "gregorian")
     assert Date.gregorian
     # an instance created with another calendar or by Date does not have
     #   the attribute; it is instead is reachable via the Date class
     d1 = Date(4)
     with pytest.raises(KeyError):
         d1.__dict__["gregorian"]
     assert hasattr(d1, "gregorian")
     d1.gregorian
     d2 = Date.iso(3, 4, 5)
     with pytest.raises(KeyError):
         d2.__dict__["gregorian"]
     assert hasattr(d2, "gregorian")
     d2.gregorian
     # a Date instance created via the calendar does have the same attribute
     d3 = Date.gregorian(3, 4, 5)
     assert hasattr(d3, "gregorian")
     d3.gregorian
예제 #18
0
 def test_020_register_new_calendar_invalid_attribute_name(self):
     with pytest.raises(ValueError):
         Date.register_new_calendar("", ExampleTestCalendar)
     with pytest.raises(ValueError):
         Date.register_new_calendar("123new", ExampleTestCalendar)
     with pytest.raises(ValueError):
         Date.register_new_calendar(123, ExampleTestCalendar)
예제 #19
0
 def test_020_register_new_calendar_invalid_attribute_name(self):
     with pytest.raises(ValueError):
         Date.register_new_calendar('', ExampleTestCalendar)
     with pytest.raises(ValueError):
         Date.register_new_calendar('123new', ExampleTestCalendar)
     with pytest.raises(ValueError):
         Date.register_new_calendar(123, ExampleTestCalendar)
예제 #20
0
    def test_020_today(self):
        """Return a Date object that represents the current local date."""
        # for the time being, let's use the good old datetime module :-)
        import datetime

        # we need to ensure that we are not testing across date change
        for dummy in range(3):
            today_before = datetime.date.today()
            date_today = Date.today()
            today_after = datetime.date.today()
            if today_before == today_after:
                break
        assert date_today.day_count == today_before.toordinal()
예제 #21
0
    def test_020_today(self):
        "Return a Date object that represents the current local date."
        # for the time being, let's use the good old datetime module :-)
        import datetime

        # we need to ensure that we are not testing across date change
        for dummy in range(3):
            today_before = datetime.date.today()
            date_today = Date.today()
            today_after = datetime.date.today()
            if today_before == today_after:
                break
        assert date_today.day_count == today_before.toordinal()
예제 #22
0
    def test_030_register_new_calendar_invalid_calendar_class(self):
        class NoFromCalendar:  # without from_rata_die
            def __init__(self, week, day):
                self.week = week
                self.day = day

            def to_rata_die(self):
                return 7 * (self.week - 1) + self.day

        with pytest.raises(TypeError):
            Date.register_new_calendar("test_1", NoFromCalendar)

        class NoToCalendar:  # without to_rata_die
            def __init__(self, week, day):
                self.week = week
                self.day = day

            @classmethod
            def from_rata_die(cls, rata_die):
                return cls((rata_die - 1) // 7 + 1, (rata_die - 1) % 7 + 1)

        with pytest.raises(TypeError):
            Date.register_new_calendar("test_1", NoToCalendar)
예제 #23
0
    def test_030_register_new_calendar_invalid_calendar_class(self):
        class NoFromCalendar:  # without from_rata_die
            def __init__(self, week, day):
                self.week = week
                self.day = day

            def to_rata_die(self):
                return 7 * (self.week - 1) + self.day

        with pytest.raises(TypeError):
            Date.register_new_calendar('test_1', NoFromCalendar)

        class NoToCalendar:  # without to_rata_die
            def __init__(self, week, day):
                self.week = week
                self.day = day

            @classmethod
            def from_rata_die(cls, rata_die):
                return cls((rata_die - 1) // 7 + 1, (rata_die - 1) % 7 + 1)

        with pytest.raises(TypeError):
            Date.register_new_calendar('test_1', NoToCalendar)
예제 #24
0
    def test_043_registered_attribute_class_with_other_constructors(
            self, clean_Date):
        class ExampleTestCalendar2(ExampleTestCalendar):
            @classmethod
            def with_thousands(cls, thousands, week, day):
                return cls(1000 * thousands + week, day)

        Date.register_new_calendar("test_2", ExampleTestCalendar2)

        # Date attribute type and metaclass are correct
        assert Date.test_2.__name__ == "ExampleTestCalendar2InDate"
        assert type(Date.test_2).__name__ == "ModifiedClass"
        assert issubclass(Date.test_2, ExampleTestCalendar)

        # constructed date type and value are is correct
        d2a = Date.test_2(100, 4)
        assert type(d2a) == Date
        assert d2a.day_count == 697
        d2d = Date.test_2.with_thousands(2, 3, 4)
        assert type(d2d) == Date
        assert d2d.day_count == 14018

        # new attribute on date instance, type and value are correct
        d2b = Date(1000)
        assert isinstance(d2b.test_2, ExampleTestCalendar2)
        assert type(d2b.test_2).__name__ == "ExampleTestCalendar2InDate"
        assert type(d2b.test_2.__class__).__name__ == "ModifiedClass"
        assert d2b.test_2.week == 143
        assert d2b.test_2.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d2c = Date.gregorian(100, 2, 3)
        assert isinstance(d2c.test_2, ExampleTestCalendar2)
        assert type(d2c.test_2).__name__ == "ExampleTestCalendar2InDate"
        assert type(d2c.test_2.__class__).__name__ == "ModifiedClass"
        assert d2c.test_2.week == 5171
        assert d2c.test_2.day == 3
예제 #25
0
    def test_043_registered_attribute_class_with_other_constructors(self, clean_Date):
        class ExampleTestCalendar2(ExampleTestCalendar):
            @classmethod
            def with_thousands(cls, thousands, week, day):
                return cls(1000 * thousands + week, day)

        Date.register_new_calendar('test_2', ExampleTestCalendar2)

        # Date attribute type and metaclass are correct
        assert Date.test_2.__name__ == 'ExampleTestCalendar2InDate'
        assert type(Date.test_2).__name__ == 'ModifiedClass'
        assert issubclass(Date.test_2, ExampleTestCalendar)

        # constructed date type and value are is correct
        d2a = Date.test_2(100, 4)
        assert type(d2a) == Date
        assert d2a.day_count == 697
        d2d = Date.test_2.with_thousands(2, 3, 4)
        assert type(d2d) == Date
        assert d2d.day_count == 14018

        # new attribute on date instance, type and value are correct
        d2b = Date(1000)
        assert isinstance(d2b.test_2, ExampleTestCalendar2)
        assert type(d2b.test_2).__name__ == 'ExampleTestCalendar2InDate'
        assert type(d2b.test_2.__class__).__name__ == 'ModifiedClass'
        assert d2b.test_2.week == 143
        assert d2b.test_2.day == 6

        # new attribute on date instance build by another calendar, type and value are correct
        d2c = Date.gregorian(100, 2, 3)
        assert isinstance(d2c.test_2, ExampleTestCalendar2)
        assert type(d2c.test_2).__name__ == 'ExampleTestCalendar2InDate'
        assert type(d2c.test_2.__class__).__name__ == 'ModifiedClass'
        assert d2c.test_2.week == 5171
        assert d2c.test_2.day == 3
예제 #26
0
    def test_920_subclass1(self):
        # check that there is no interference from the interface mechanism and from possible additional arguments
        class D(Date):
            theAnswer = 42

            def __init__(self, *args, **kws):
                temp = kws.copy()
                self.extra = temp.pop("extra")
                Date.__init__(self, *args, **temp)

            def newmeth(self, start):
                return start + (self.day_count * 3) // 2

        d1 = Date(102013)
        d2 = D(102013, extra=7)

        assert d2.theAnswer == 42
        assert d2.extra == 7
        assert d1.day_count == d2.day_count
        assert d2.newmeth(-7) == (d1.day_count * 3) // 2 - 7
예제 #27
0
 def test_100_write_attribute(self):
     "This attribute is read-only."
     d = Date(1)
     with pytest.raises(AttributeError):
         d.day_count = 3
예제 #28
0
    def test_320_comparisons(self):
        d1 = Date(42)
        d2 = Date(42)
        assert d1 == d2
        assert d1 <= d2
        assert d1 >= d2
        assert not (d1 != d2)
        assert not (d1 < d2)
        assert not (d1 > d2)

        d3 = Date(4242)  # this is larger than d1
        assert d1 < d3
        assert d3 > d1
        assert d1 <= d3
        assert d3 >= d1
        assert d1 != d3
        assert d3 != d1
        assert not (d1 == d3)
        assert not (d3 == d1)
        assert not (d1 > d3)
        assert not (d3 < d1)
        assert not (d1 >= d3)
        assert not (d3 <= d1)

        # Reverse comparison mechanism
        class DateLike:
            def __init__(self):
                self.day_count = 42

            def __eq__(self, other):
                return self.day_count == other.day_count

            def __ne__(self, other):
                return self.day_count != other.day_count

            def __lt__(self, other):
                return self.day_count < other.day_count

            def __le__(self, other):
                return self.day_count <= other.day_count

            def __gt__(self, other):
                return self.day_count > other.day_count

            def __ge__(self, other):
                return self.day_count >= other.day_count

        dl = DateLike()
        d4 = Date(4)
        d42 = Date(42)
        d55 = Date(55)
        assert not (d4 == dl)
        assert d42 == dl
        assert not (d55 == dl)
        assert d4 != dl
        assert not (d42 != dl)
        assert d55 != dl
        assert d4 < dl
        assert not (d42 < dl)
        assert not (d55 < dl)
        assert d4 <= dl
        assert d42 <= dl
        assert not (d55 <= dl)
        assert not (d4 > dl)
        assert not (d42 > dl)
        assert d55 > dl
        assert not (d4 >= dl)
        assert d42 >= dl
        assert d55 >= dl
예제 #29
0
 def test_010_register_new_calendar_existing_calendar_or_attribute(self):
     with pytest.raises(AttributeError):
         Date.register_new_calendar("gregorian", ExampleTestCalendar)
     with pytest.raises(AttributeError):
         Date.register_new_calendar("day_count", ExampleTestCalendar)
예제 #30
0
 def test_350_bool(self):
     """In boolean contexts, all Date instances are considered to be true."""
     for day_count in date_test_data:
         assert Date(day_count)
예제 #31
0
 def test_520_str(self):
     for day_count in date_test_data:
         d = Date(day_count)
         assert int(str(d)[5:]) == day_count
예제 #32
0
 def __init__(self, *args, **kws):
     temp = kws.copy()
     self.extra = temp.pop("extra")
     Date.__init__(self, *args, **temp)
예제 #33
0
 def test_000_valid_parameter_types(self):
     """The argument is required and must be an integer."""
     for day_count in date_test_data:
         assert Date(day_count).day_count == day_count
예제 #34
0
 def test_100_write_attribute(self):
     """This attribute is read-only."""
     d = Date(1)
     with pytest.raises(AttributeError):
         d.day_count = 3
예제 #35
0
 def test_010_register_new_calendar_existing_calendar_or_attribute(self):
     with pytest.raises(AttributeError):
         Date.register_new_calendar('gregorian', ExampleTestCalendar)
     with pytest.raises(AttributeError):
         Date.register_new_calendar('day_count', ExampleTestCalendar)
예제 #36
0
 def __init__(self, *args, **kws):
     temp = kws.copy()
     self.extra = temp.pop('extra')
     Date.__init__(self, *args, **temp)
예제 #37
0
    def test_300_valid_operations(self):
        a = Date(0)
        b = Date(-3)
        c = Date(5)
        zero = TimeDelta(0)
        one = TimeDelta(1)
        minusone = TimeDelta(-1)

        # Addition between Date and TimeDelta
        # test with zero, negative and positive dates
        assert a + zero == Date(0)
        assert a + one == Date(1)
        assert a + minusone == Date(-1)
        assert b + zero == Date(-3)
        assert b + one == Date(-2)
        assert b + minusone == Date(-4)
        assert c + zero == Date(5)
        assert c + one == Date(6)
        assert c + minusone == Date(4)

        # Reverse addition between TimeDelta and Date
        # test with zero, negative and positive dates
        assert zero + a == Date(0)
        assert one + a == Date(1)
        assert minusone + a == Date(-1)
        assert zero + b == Date(-3)
        assert one + b == Date(-2)
        assert minusone + b == Date(-4)
        assert zero + c == Date(5)
        assert one + c == Date(6)
        assert minusone + c == Date(4)

        # subtraction between Date and TimeDelta, reverse is not defined
        # test with zero, negative and positive dates
        assert a - zero == Date(0)
        assert a - one == Date(-1)
        assert a - minusone == Date(1)
        assert b - zero == Date(-3)
        assert b - one == Date(-4)
        assert b - minusone == Date(-2)
        assert c - zero == Date(5)
        assert c - one == Date(4)
        assert c - minusone == Date(6)

        # subtraction between two Date's, reverse is not defined
        # test with zero, negative and positive dates
        assert a - a == TimeDelta(0)
        assert a - b == TimeDelta(3)
        assert a - c == TimeDelta(-5)
        assert b - a == TimeDelta(-3)
        assert b - b == TimeDelta(0)
        assert b - c == TimeDelta(-8)
        assert c - a == TimeDelta(5)
        assert c - b == TimeDelta(8)
        assert c - c == TimeDelta(0)