602 lines
23 KiB
Python
602 lines
23 KiB
Python
##############################################################################
|
|
# Copyright 2009, Gerhard Weis
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright notice,
|
|
# this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions and the following disclaimer in the documentation
|
|
# and/or other materials provided with the distribution.
|
|
# * Neither the name of the authors nor the names of its contributors
|
|
# may be used to endorse or promote products derived from this software
|
|
# without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
# CONTRACT, STRICT LIABILITY, OR TORT
|
|
##############################################################################
|
|
'''
|
|
Test cases for the isoduration module.
|
|
'''
|
|
import unittest
|
|
import operator
|
|
from datetime import timedelta, date, datetime
|
|
|
|
from isodate import Duration, parse_duration, ISO8601Error
|
|
from isodate import D_DEFAULT, D_WEEK, D_ALT_EXT, duration_isoformat
|
|
|
|
# the following list contains tuples of ISO duration strings and the expected
|
|
# result from the parse_duration method. A result of None means an ISO8601Error
|
|
# is expected.
|
|
PARSE_TEST_CASES = {'P18Y9M4DT11H9M8S': (Duration(4, 8, 0, 0, 9, 11, 0, 9, 18),
|
|
D_DEFAULT, None),
|
|
'P2W': (timedelta(weeks=2), D_WEEK, None),
|
|
'P3Y6M4DT12H30M5S': (Duration(4, 5, 0, 0, 30, 12, 0, 6, 3),
|
|
D_DEFAULT, None),
|
|
'P23DT23H': (timedelta(hours=23, days=23),
|
|
D_DEFAULT, None),
|
|
'P4Y': (Duration(years=4), D_DEFAULT, None),
|
|
'P1M': (Duration(months=1), D_DEFAULT, None),
|
|
'PT1M': (timedelta(minutes=1), D_DEFAULT, None),
|
|
'P0.5Y': (Duration(years=0.5), D_DEFAULT, None),
|
|
'PT36H': (timedelta(hours=36), D_DEFAULT, 'P1DT12H'),
|
|
'P1DT12H': (timedelta(days=1, hours=12), D_DEFAULT, None),
|
|
'+P11D': (timedelta(days=11), D_DEFAULT, 'P11D'),
|
|
'-P2W': (timedelta(weeks=-2), D_WEEK, None),
|
|
'-P2.2W': (timedelta(weeks=-2.2), D_DEFAULT,
|
|
'-P15DT9H36M'),
|
|
'P1DT2H3M4S': (timedelta(days=1, hours=2, minutes=3,
|
|
seconds=4), D_DEFAULT, None),
|
|
'P1DT2H3M': (timedelta(days=1, hours=2, minutes=3),
|
|
D_DEFAULT, None),
|
|
'P1DT2H': (timedelta(days=1, hours=2), D_DEFAULT, None),
|
|
'PT2H': (timedelta(hours=2), D_DEFAULT, None),
|
|
'PT2.3H': (timedelta(hours=2.3), D_DEFAULT, 'PT2H18M'),
|
|
'PT2H3M4S': (timedelta(hours=2, minutes=3, seconds=4),
|
|
D_DEFAULT, None),
|
|
'PT3M4S': (timedelta(minutes=3, seconds=4), D_DEFAULT,
|
|
None),
|
|
'PT22S': (timedelta(seconds=22), D_DEFAULT, None),
|
|
'PT22.22S': (timedelta(seconds=22.22), 'PT%S.%fS',
|
|
'PT22.220000S'),
|
|
'-P2Y': (Duration(years=-2), D_DEFAULT, None),
|
|
'-P3Y6M4DT12H30M5S': (Duration(-4, -5, 0, 0, -30, -12, 0,
|
|
-6, -3), D_DEFAULT, None),
|
|
'-P1DT2H3M4S': (timedelta(days=-1, hours=-2, minutes=-3,
|
|
seconds=-4), D_DEFAULT, None),
|
|
# alternative format
|
|
'P0018-09-04T11:09:08': (Duration(4, 8, 0, 0, 9, 11, 0, 9,
|
|
18), D_ALT_EXT, None),
|
|
# 'PT000022.22': timedelta(seconds=22.22),
|
|
}
|
|
|
|
# d1 d2 '+', '-', '>'
|
|
# A list of test cases to test addition and subtraction between datetime and
|
|
# Duration objects.
|
|
# each tuple contains 2 duration strings, and a result string for addition and
|
|
# one for subtraction. The last value says, if the first duration is greater
|
|
# than the second.
|
|
MATH_TEST_CASES = (('P5Y7M1DT9H45M16.72S', 'PT27M24.68S',
|
|
'P5Y7M1DT10H12M41.4S', 'P5Y7M1DT9H17M52.04S', None),
|
|
('PT28M12.73S', 'PT56M29.92S',
|
|
'PT1H24M42.65S', '-PT28M17.19S', False),
|
|
('P3Y7M23DT5H25M0.33S', 'PT1H1.95S',
|
|
'P3Y7M23DT6H25M2.28S', 'P3Y7M23DT4H24M58.38S', None),
|
|
('PT1H1.95S', 'P3Y7M23DT5H25M0.33S',
|
|
'P3Y7M23DT6H25M2.28S', '-P3Y7M23DT4H24M58.38S', None),
|
|
('P1332DT55M0.33S', 'PT1H1.95S',
|
|
'P1332DT1H55M2.28S', 'P1331DT23H54M58.38S', True),
|
|
('PT1H1.95S', 'P1332DT55M0.33S',
|
|
'P1332DT1H55M2.28S', '-P1331DT23H54M58.38S', False))
|
|
|
|
|
|
# A list of test cases to test addition and subtraction of date/datetime
|
|
# and Duration objects. They are tested against the results of an
|
|
# equal long timedelta duration.
|
|
DATE_TEST_CASES = ((date(2008, 2, 29),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(date(2008, 1, 31),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(datetime(2008, 2, 29),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(datetime(2008, 1, 31),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(datetime(2008, 4, 21),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(datetime(2008, 5, 5),
|
|
timedelta(days=10, hours=12, minutes=20),
|
|
Duration(days=10, hours=12, minutes=20)),
|
|
(datetime(2000, 1, 1),
|
|
timedelta(hours=-33),
|
|
Duration(hours=-33)),
|
|
(datetime(2008, 5, 5),
|
|
Duration(years=1, months=1, days=10, hours=12,
|
|
minutes=20),
|
|
Duration(months=13, days=10, hours=12, minutes=20)),
|
|
(datetime(2000, 3, 30),
|
|
Duration(years=1, months=1, days=10, hours=12,
|
|
minutes=20),
|
|
Duration(months=13, days=10, hours=12, minutes=20)),
|
|
)
|
|
|
|
# A list of test cases of additon of date/datetime and Duration. The results
|
|
# are compared against a given expected result.
|
|
DATE_CALC_TEST_CASES = (
|
|
(date(2000, 2, 1),
|
|
Duration(years=1, months=1),
|
|
date(2001, 3, 1)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=1, months=1),
|
|
date(2001, 3, 29)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=1),
|
|
date(2001, 2, 28)),
|
|
(date(1996, 2, 29),
|
|
Duration(years=4),
|
|
date(2000, 2, 29)),
|
|
(date(2096, 2, 29),
|
|
Duration(years=4),
|
|
date(2100, 2, 28)),
|
|
(date(2000, 2, 1),
|
|
Duration(years=-1, months=-1),
|
|
date(1999, 1, 1)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=-1, months=-1),
|
|
date(1999, 1, 29)),
|
|
(date(2000, 2, 1),
|
|
Duration(years=1, months=1, days=1),
|
|
date(2001, 3, 2)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=1, months=1, days=1),
|
|
date(2001, 3, 30)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=1, days=1),
|
|
date(2001, 3, 1)),
|
|
(date(1996, 2, 29),
|
|
Duration(years=4, days=1),
|
|
date(2000, 3, 1)),
|
|
(date(2096, 2, 29),
|
|
Duration(years=4, days=1),
|
|
date(2100, 3, 1)),
|
|
(date(2000, 2, 1),
|
|
Duration(years=-1, months=-1, days=-1),
|
|
date(1998, 12, 31)),
|
|
(date(2000, 2, 29),
|
|
Duration(years=-1, months=-1, days=-1),
|
|
date(1999, 1, 28)),
|
|
(date(2001, 4, 1),
|
|
Duration(years=-1, months=-1, days=-1),
|
|
date(2000, 2, 29)),
|
|
(date(2000, 4, 1),
|
|
Duration(years=-1, months=-1, days=-1),
|
|
date(1999, 2, 28)),
|
|
(Duration(years=1, months=2),
|
|
Duration(years=0, months=0, days=1),
|
|
Duration(years=1, months=2, days=1)),
|
|
(Duration(years=-1, months=-1, days=-1),
|
|
date(2000, 4, 1),
|
|
date(1999, 2, 28)),
|
|
(Duration(years=1, months=1, weeks=5),
|
|
date(2000, 1, 30),
|
|
date(2001, 4, 4)),
|
|
(parse_duration("P1Y1M5W"),
|
|
date(2000, 1, 30),
|
|
date(2001, 4, 4)),
|
|
(parse_duration("P0.5Y"),
|
|
date(2000, 1, 30),
|
|
None),
|
|
(Duration(years=1, months=1, hours=3),
|
|
datetime(2000, 1, 30, 12, 15, 00),
|
|
datetime(2001, 2, 28, 15, 15, 00)),
|
|
(parse_duration("P1Y1MT3H"),
|
|
datetime(2000, 1, 30, 12, 15, 00),
|
|
datetime(2001, 2, 28, 15, 15, 00)),
|
|
(Duration(years=1, months=2),
|
|
timedelta(days=1),
|
|
Duration(years=1, months=2, days=1)),
|
|
(timedelta(days=1),
|
|
Duration(years=1, months=2),
|
|
Duration(years=1, months=2, days=1)),
|
|
(datetime(2008, 1, 1, 0, 2),
|
|
Duration(months=1),
|
|
datetime(2008, 2, 1, 0, 2)),
|
|
(datetime.strptime("200802", "%Y%M"),
|
|
parse_duration("P1M"),
|
|
datetime(2008, 2, 1, 0, 2)),
|
|
(datetime(2008, 2, 1),
|
|
Duration(months=1),
|
|
datetime(2008, 3, 1)),
|
|
(datetime.strptime("200802", "%Y%m"),
|
|
parse_duration("P1M"),
|
|
datetime(2008, 3, 1)),
|
|
# (date(2000, 1, 1),
|
|
# Duration(years=1.5),
|
|
# date(2001, 6, 1)),
|
|
# (date(2000, 1, 1),
|
|
# Duration(years=1, months=1.5),
|
|
# date(2001, 2, 14)),
|
|
)
|
|
|
|
# A list of test cases of multiplications of durations
|
|
# are compared against a given expected result.
|
|
DATE_MUL_TEST_CASES = (
|
|
(Duration(years=1, months=1),
|
|
3,
|
|
Duration(years=3, months=3)),
|
|
(Duration(years=1, months=1),
|
|
-3,
|
|
Duration(years=-3, months=-3)),
|
|
(3,
|
|
Duration(years=1, months=1),
|
|
Duration(years=3, months=3)),
|
|
(-3,
|
|
Duration(years=1, months=1),
|
|
Duration(years=-3, months=-3)),
|
|
(5,
|
|
Duration(years=2, minutes=40),
|
|
Duration(years=10, hours=3, minutes=20)),
|
|
(-5,
|
|
Duration(years=2, minutes=40),
|
|
Duration(years=-10, hours=-3, minutes=-20)),
|
|
(7,
|
|
Duration(years=1, months=2, weeks=40),
|
|
Duration(years=8, months=2, weeks=280)))
|
|
|
|
|
|
class DurationTest(unittest.TestCase):
|
|
'''
|
|
This class tests various other aspects of the isoduration module,
|
|
which are not covered with the test cases listed above.
|
|
'''
|
|
|
|
def test_associative(self):
|
|
'''
|
|
Adding 2 durations to a date is not associative.
|
|
'''
|
|
days1 = Duration(days=1)
|
|
months1 = Duration(months=1)
|
|
start = date(2000, 3, 30)
|
|
res1 = start + days1 + months1
|
|
res2 = start + months1 + days1
|
|
self.assertNotEqual(res1, res2)
|
|
|
|
def test_typeerror(self):
|
|
'''
|
|
Test if TypError is raised with certain parameters.
|
|
'''
|
|
self.assertRaises(TypeError, parse_duration, date(2000, 1, 1))
|
|
self.assertRaises(TypeError, operator.sub, Duration(years=1),
|
|
date(2000, 1, 1))
|
|
self.assertRaises(TypeError, operator.sub, 'raise exc',
|
|
Duration(years=1))
|
|
self.assertRaises(TypeError, operator.add,
|
|
Duration(years=1, months=1, weeks=5),
|
|
'raise exception')
|
|
self.assertRaises(TypeError, operator.add, 'raise exception',
|
|
Duration(years=1, months=1, weeks=5))
|
|
self.assertRaises(TypeError, operator.mul,
|
|
Duration(years=1, months=1, weeks=5),
|
|
'raise exception')
|
|
self.assertRaises(TypeError, operator.mul, 'raise exception',
|
|
Duration(years=1, months=1, weeks=5))
|
|
self.assertRaises(TypeError, operator.mul,
|
|
Duration(years=1, months=1, weeks=5),
|
|
3.14)
|
|
self.assertRaises(TypeError, operator.mul, 3.14,
|
|
Duration(years=1, months=1, weeks=5))
|
|
|
|
def test_parseerror(self):
|
|
'''
|
|
Test for unparseable duration string.
|
|
'''
|
|
self.assertRaises(ISO8601Error, parse_duration, 'T10:10:10')
|
|
|
|
def test_repr(self):
|
|
'''
|
|
Test __repr__ and __str__ for Duration objects.
|
|
'''
|
|
dur = Duration(10, 10, years=10, months=10)
|
|
self.assertEqual('10 years, 10 months, 10 days, 0:00:10', str(dur))
|
|
self.assertEqual('isodate.duration.Duration(10, 10, 0,'
|
|
' years=10, months=10)', repr(dur))
|
|
|
|
def test_hash(self):
|
|
'''
|
|
Test __hash__ for Duration objects.
|
|
'''
|
|
dur1 = Duration(10, 10, years=10, months=10)
|
|
dur2 = Duration(9, 9, years=9, months=9)
|
|
dur3 = Duration(10, 10, years=10, months=10)
|
|
self.assertNotEqual(hash(dur1), hash(dur2))
|
|
self.assertNotEqual(id(dur1), id(dur2))
|
|
self.assertEqual(hash(dur1), hash(dur3))
|
|
self.assertNotEqual(id(dur1), id(dur3))
|
|
durSet = set()
|
|
durSet.add(dur1)
|
|
durSet.add(dur2)
|
|
durSet.add(dur3)
|
|
self.assertEqual(len(durSet), 2)
|
|
|
|
def test_neg(self):
|
|
'''
|
|
Test __neg__ for Duration objects.
|
|
'''
|
|
self.assertEqual(-Duration(0), Duration(0))
|
|
self.assertEqual(-Duration(years=1, months=1),
|
|
Duration(years=-1, months=-1))
|
|
self.assertEqual(-Duration(years=1, months=1), Duration(months=-13))
|
|
self.assertNotEqual(-Duration(years=1), timedelta(days=-365))
|
|
self.assertNotEqual(-timedelta(days=365), Duration(years=-1))
|
|
# FIXME: this test fails in python 3... it seems like python3
|
|
# treats a == b the same b == a
|
|
# self.assertNotEqual(-timedelta(days=10), -Duration(days=10))
|
|
|
|
def test_format(self):
|
|
'''
|
|
Test various other strftime combinations.
|
|
'''
|
|
self.assertEqual(duration_isoformat(Duration(0)), 'P0D')
|
|
self.assertEqual(duration_isoformat(-Duration(0)), 'P0D')
|
|
self.assertEqual(duration_isoformat(Duration(seconds=10)), 'PT10S')
|
|
self.assertEqual(duration_isoformat(Duration(years=-1, months=-1)),
|
|
'-P1Y1M')
|
|
self.assertEqual(duration_isoformat(-Duration(years=1, months=1)),
|
|
'-P1Y1M')
|
|
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
|
|
'P1Y1M')
|
|
self.assertEqual(duration_isoformat(-Duration(years=-1, months=-1)),
|
|
'P1Y1M')
|
|
dur = Duration(years=3, months=7, days=23, hours=5, minutes=25,
|
|
milliseconds=330)
|
|
self.assertEqual(duration_isoformat(dur), 'P3Y7M23DT5H25M0.33S')
|
|
self.assertEqual(duration_isoformat(-dur), '-P3Y7M23DT5H25M0.33S')
|
|
|
|
def test_equal(self):
|
|
'''
|
|
Test __eq__ and __ne__ methods.
|
|
'''
|
|
self.assertEqual(Duration(years=1, months=1),
|
|
Duration(years=1, months=1))
|
|
self.assertEqual(Duration(years=1, months=1), Duration(months=13))
|
|
self.assertNotEqual(Duration(years=1, months=2),
|
|
Duration(years=1, months=1))
|
|
self.assertNotEqual(Duration(years=1, months=1), Duration(months=14))
|
|
self.assertNotEqual(Duration(years=1), timedelta(days=365))
|
|
self.assertFalse(Duration(years=1, months=1) !=
|
|
Duration(years=1, months=1))
|
|
self.assertFalse(Duration(years=1, months=1) != Duration(months=13))
|
|
self.assertTrue(Duration(years=1, months=2) !=
|
|
Duration(years=1, months=1))
|
|
self.assertTrue(Duration(years=1, months=1) != Duration(months=14))
|
|
self.assertTrue(Duration(years=1) != timedelta(days=365))
|
|
self.assertEqual(Duration(days=1), timedelta(days=1))
|
|
# FIXME: this test fails in python 3... it seems like python3
|
|
# treats a != b the same b != a
|
|
# self.assertNotEqual(timedelta(days=1), Duration(days=1))
|
|
|
|
def test_totimedelta(self):
|
|
'''
|
|
Test conversion form Duration to timedelta.
|
|
'''
|
|
dur = Duration(years=1, months=2, days=10)
|
|
self.assertEqual(dur.totimedelta(datetime(1998, 2, 25)),
|
|
timedelta(434))
|
|
# leap year has one day more in february
|
|
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)),
|
|
timedelta(435))
|
|
dur = Duration(months=2)
|
|
# march is longer than february, but april is shorter than
|
|
# march (cause only one day difference compared to 2)
|
|
self.assertEqual(dur.totimedelta(datetime(2000, 2, 25)), timedelta(60))
|
|
self.assertEqual(dur.totimedelta(datetime(2001, 2, 25)), timedelta(59))
|
|
self.assertEqual(dur.totimedelta(datetime(2001, 3, 25)), timedelta(61))
|
|
|
|
|
|
def create_parsetestcase(durationstring, expectation, format, altstr):
|
|
"""
|
|
Create a TestCase class for a specific test.
|
|
|
|
This allows having a separate TestCase for each test tuple from the
|
|
PARSE_TEST_CASES list, so that a failed test won't stop other tests.
|
|
"""
|
|
|
|
class TestParseDuration(unittest.TestCase):
|
|
'''
|
|
A test case template to parse an ISO duration string into a
|
|
timedelta or Duration object.
|
|
'''
|
|
|
|
def test_parse(self):
|
|
'''
|
|
Parse an ISO duration string and compare it to the expected value.
|
|
'''
|
|
result = parse_duration(durationstring)
|
|
self.assertEqual(result, expectation)
|
|
|
|
def test_format(self):
|
|
'''
|
|
Take duration/timedelta object and create ISO string from it.
|
|
This is the reverse test to test_parse.
|
|
'''
|
|
if altstr:
|
|
self.assertEqual(duration_isoformat(expectation, format),
|
|
altstr)
|
|
else:
|
|
# if durationstring == '-P2W':
|
|
# import pdb; pdb.set_trace()
|
|
self.assertEqual(duration_isoformat(expectation, format),
|
|
durationstring)
|
|
|
|
return unittest.TestLoader().loadTestsFromTestCase(TestParseDuration)
|
|
|
|
|
|
def create_mathtestcase(dur1, dur2, resadd, ressub, resge):
|
|
"""
|
|
Create a TestCase class for a specific test.
|
|
|
|
This allows having a separate TestCase for each test tuple from the
|
|
MATH_TEST_CASES list, so that a failed test won't stop other tests.
|
|
"""
|
|
|
|
dur1 = parse_duration(dur1)
|
|
dur2 = parse_duration(dur2)
|
|
resadd = parse_duration(resadd)
|
|
ressub = parse_duration(ressub)
|
|
|
|
class TestMathDuration(unittest.TestCase):
|
|
'''
|
|
A test case template test addition, subtraction and >
|
|
operators for Duration objects.
|
|
'''
|
|
|
|
def test_add(self):
|
|
'''
|
|
Test operator + (__add__, __radd__)
|
|
'''
|
|
self.assertEqual(dur1 + dur2, resadd)
|
|
|
|
def test_sub(self):
|
|
'''
|
|
Test operator - (__sub__, __rsub__)
|
|
'''
|
|
self.assertEqual(dur1 - dur2, ressub)
|
|
|
|
def test_ge(self):
|
|
'''
|
|
Test operator > and <
|
|
'''
|
|
def dogetest():
|
|
''' Test greater than.'''
|
|
return dur1 > dur2
|
|
|
|
def doletest():
|
|
''' Test less than.'''
|
|
return dur1 < dur2
|
|
if resge is None:
|
|
self.assertRaises(TypeError, dogetest)
|
|
self.assertRaises(TypeError, doletest)
|
|
else:
|
|
self.assertEqual(dogetest(), resge)
|
|
self.assertEqual(doletest(), not resge)
|
|
|
|
return unittest.TestLoader().loadTestsFromTestCase(TestMathDuration)
|
|
|
|
|
|
def create_datetestcase(start, tdelta, duration):
|
|
"""
|
|
Create a TestCase class for a specific test.
|
|
|
|
This allows having a separate TestCase for each test tuple from the
|
|
DATE_TEST_CASES list, so that a failed test won't stop other tests.
|
|
"""
|
|
|
|
class TestDateCalc(unittest.TestCase):
|
|
'''
|
|
A test case template test addition, subtraction
|
|
operators for Duration objects.
|
|
'''
|
|
|
|
def test_add(self):
|
|
'''
|
|
Test operator +.
|
|
'''
|
|
self.assertEqual(start + tdelta, start + duration)
|
|
|
|
def test_sub(self):
|
|
'''
|
|
Test operator -.
|
|
'''
|
|
self.assertEqual(start - tdelta, start - duration)
|
|
|
|
return unittest.TestLoader().loadTestsFromTestCase(TestDateCalc)
|
|
|
|
|
|
def create_datecalctestcase(start, duration, expectation):
|
|
"""
|
|
Create a TestCase class for a specific test.
|
|
|
|
This allows having a separate TestCase for each test tuple from the
|
|
DATE_CALC_TEST_CASES list, so that a failed test won't stop other tests.
|
|
"""
|
|
|
|
class TestDateCalc(unittest.TestCase):
|
|
'''
|
|
A test case template test addition operators for Duration objects.
|
|
'''
|
|
|
|
def test_calc(self):
|
|
'''
|
|
Test operator +.
|
|
'''
|
|
if expectation is None:
|
|
self.assertRaises(ValueError, operator.add, start, duration)
|
|
else:
|
|
self.assertEqual(start + duration, expectation)
|
|
|
|
return unittest.TestLoader().loadTestsFromTestCase(TestDateCalc)
|
|
|
|
|
|
def create_datemultestcase(operand1, operand2, expectation):
|
|
"""
|
|
Create a TestCase class for a specific test.
|
|
|
|
This allows having a separate TestCase for each test tuple from the
|
|
DATE_CALC_TEST_CASES list, so that a failed test won't stop other tests.
|
|
"""
|
|
|
|
class TestDateMul(unittest.TestCase):
|
|
'''
|
|
A test case template test addition operators for Duration objects.
|
|
'''
|
|
|
|
def test_mul(self):
|
|
'''
|
|
Test operator *.
|
|
'''
|
|
self.assertEqual(operand1 * operand2, expectation)
|
|
|
|
return unittest.TestLoader().loadTestsFromTestCase(TestDateMul)
|
|
|
|
|
|
def test_suite():
|
|
'''
|
|
Return a test suite containing all test defined above.
|
|
'''
|
|
suite = unittest.TestSuite()
|
|
for durationstring, (expectation, format,
|
|
altstr) in PARSE_TEST_CASES.items():
|
|
suite.addTest(create_parsetestcase(durationstring, expectation,
|
|
format, altstr))
|
|
for testdata in MATH_TEST_CASES:
|
|
suite.addTest(create_mathtestcase(*testdata))
|
|
for testdata in DATE_TEST_CASES:
|
|
suite.addTest(create_datetestcase(*testdata))
|
|
for testdata in DATE_CALC_TEST_CASES:
|
|
suite.addTest(create_datecalctestcase(*testdata))
|
|
for testdata in DATE_MUL_TEST_CASES:
|
|
suite.addTest(create_datemultestcase(*testdata))
|
|
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(DurationTest))
|
|
return suite
|
|
|
|
|
|
# load_tests Protocol
|
|
def load_tests(loader, tests, pattern):
|
|
return test_suite()
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(defaultTest='test_suite')
|