"""Test date/time type.

See http://www.zope.org/Members/fdrake/DateTimeWiki/TestCases

"""

from test.support import is_resource_enabled

import itertools

import bisect

import copy

import decimal

import sys

import os

import pickle

import random

import struct

import unittest

from array import array

from operator import lt, le, gt, ge, eq, ne, truediv, floordiv, mod

from test import support

import datetime as datetime_module

from datetime import MINYEAR, MAXYEAR

from datetime import timedelta

from datetime import tzinfo

from datetime import time

from datetime import timezone

from datetime import date, datetime

import time as _time

# Needed by test_datetime

import _strptime

#

pickle_choices = [(pickle, pickle, proto)

for proto in range(pickle.HIGHEST_PROTOCOL + 1)]

assert len(pickle_choices) == pickle.HIGHEST_PROTOCOL + 1

# An arbitrary collection of objects of non-datetime types, for testing

# mixed-type comparisons.

OTHERSTUFF = (10, 34.5, "abc", {}, [], ())

# XXX Copied from test_float.

INF = float("inf")

NAN = float("nan")

#############################################################################

# module tests

class TestModule(unittest.TestCase):

def test_constants(self):

datetime = datetime_module

self.assertEqual(datetime.MINYEAR, 1)

self.assertEqual(datetime.MAXYEAR, 9999)

def test_name_cleanup(self):

if '_Fast' not in str(self):

return

datetime = datetime_module

names = set(name for name in dir(datetime)

if not name.startswith('__') and not name.endswith('__'))

allowed = set(['MAXYEAR', 'MINYEAR', 'date', 'datetime',

'datetime_CAPI', 'time', 'timedelta', 'timezone',

'tzinfo'])

self.assertEqual(names - allowed, set([]))

def test_divide_and_round(self):

if '_Fast' in str(self):

return

dar = datetime_module._divide_and_round

self.assertEqual(dar(-10, -3), 3)

self.assertEqual(dar(5, -2), -2)

# four cases: (2 signs of a) x (2 signs of b)

self.assertEqual(dar(7, 3), 2)

self.assertEqual(dar(-7, 3), -2)

self.assertEqual(dar(7, -3), -2)

self.assertEqual(dar(-7, -3), 2)

# ties to even - eight cases:

# (2 signs of a) x (2 signs of b) x (even / odd quotient)

self.assertEqual(dar(10, 4), 2)

self.assertEqual(dar(-10, 4), -2)

self.assertEqual(dar(10, -4), -2)

self.assertEqual(dar(-10, -4), 2)

self.assertEqual(dar(6, 4), 2)

self.assertEqual(dar(-6, 4), -2)

self.assertEqual(dar(6, -4), -2)

self.assertEqual(dar(-6, -4), 2)

#############################################################################

# tzinfo tests

class FixedOffset(tzinfo):

def __init__(self, offset, name, dstoffset=42):

if isinstance(offset, int):

offset = timedelta(minutes=offset)

if isinstance(dstoffset, int):

dstoffset = timedelta(minutes=dstoffset)

self.__offset = offset

self.__name = name

self.__dstoffset = dstoffset

def __repr__(self):

return self.__name.lower()

def utcoffset(self, dt):

return self.__offset

def tzname(self, dt):

return self.__name

def dst(self, dt):

return self.__dstoffset

class PicklableFixedOffset(FixedOffset):

def __init__(self, offset=None, name=None, dstoffset=None):

FixedOffset.__init__(self, offset, name, dstoffset)

def __getstate__(self):

return self.__dict__

class _TZInfo(tzinfo):

def utcoffset(self, datetime_module):

return random.random()

class TestTZInfo(unittest.TestCase):

def test_refcnt_crash_bug_22044(self):

tz1 = _TZInfo()

dt1 = datetime(2014, 7, 21, 11, 32, 3, 0, tz1)

with self.assertRaises(TypeError):

dt1.utcoffset()

def test_non_abstractness(self):

# In order to allow subclasses to get pickled, the C implementation

# wasn't able to get away with having __init__ raise

# NotImplementedError.

useless = tzinfo()

dt = datetime.max

self.assertRaises(NotImplementedError, useless.tzname, dt)

self.assertRaises(NotImplementedError, useless.utcoffset, dt)

self.assertRaises(NotImplementedError, useless.dst, dt)

def test_subclass_must_override(self):

class NotEnough(tzinfo):

def __init__(self, offset, name):

self.__offset = offset

self.__name = name

self.assertTrue(issubclass(NotEnough, tzinfo))

ne = NotEnough(3, "NotByALongShot")

self.assertIsInstance(ne, tzinfo)

dt = datetime.now()

self.assertRaises(NotImplementedError, ne.tzname, dt)

self.assertRaises(NotImplementedError, ne.utcoffset, dt)

self.assertRaises(NotImplementedError, ne.dst, dt)

def test_normal(self):

fo = FixedOffset(3, "Three")

self.assertIsInstance(fo, tzinfo)

for dt in datetime.now(), None:

self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))

self.assertEqual(fo.tzname(dt), "Three")

self.assertEqual(fo.dst(dt), timedelta(minutes=42))

def test_pickling_base(self):

# There's no point to pickling tzinfo objects on their own (they

# carry no data), but they need to be picklable anyway else

# concrete subclasses can't be pickled.

orig = tzinfo.__new__(tzinfo)

self.assertIs(type(orig), tzinfo)

for pickler, unpickler, proto in pickle_choices:

green = pickler.dumps(orig, proto)

derived = unpickler.loads(green)

self.assertIs(type(derived), tzinfo)

def test_pickling_subclass(self):

# Make sure we can pickle/unpickle an instance of a subclass.

offset = timedelta(minutes=-300)

for otype, args in [

(PicklableFixedOffset, (offset, 'cookie')),

(timezone, (offset,)),

(timezone, (offset, "EST"))]:

orig = otype(*args)

oname = orig.tzname(None)

self.assertIsInstance(orig, tzinfo)

self.assertIs(type(orig), otype)

self.assertEqual(orig.utcoffset(None), offset)

self.assertEqual(orig.tzname(None), oname)

for pickler, unpickler, proto in pickle_choices:

green = pickler.dumps(orig, proto)

derived = unpickler.loads(green)

self.assertIsInstance(derived, tzinfo)

self.assertIs(type(derived), otype)

self.assertEqual(derived.utcoffset(None), offset)

self.assertEqual(derived.tzname(None), oname)

def test_issue23600(self):

DSTDIFF = DSTOFFSET = timedelta(hours=1)

class UKSummerTime(tzinfo):

"""Simple time zone which pretends to always be in summer time, since

that's what shows the failure.

"""

def utcoffset(self, dt):

return DSTOFFSET

def dst(self, dt):

return DSTDIFF

def tzname(self, dt):

return 'UKSummerTime'

tz = UKSummerTime()

u = datetime(2014, 4, 26, 12, 1, tzinfo=tz)

t = tz.fromutc(u)

self.assertEqual(t - t.utcoffset(), u)

class TestTimeZone(unittest.TestCase):

def setUp(self):

self.ACDT = timezone(timedelta(hours=9.5), 'ACDT')

self.EST = timezone(-timedelta(hours=5), 'EST')

self.DT = datetime(2010, 1, 1)

def test_str(self):

for tz in [self.ACDT, self.EST, timezone.utc,

timezone.min, timezone.max]:

self.assertEqual(str(tz), tz.tzname(None))

def test_repr(self):

datetime = datetime_module

for tz in [self.ACDT, self.EST, timezone.utc,

timezone.min, timezone.max]:

# test round-trip

tzrep = repr(tz)

self.assertEqual(tz, eval(tzrep))

def test_class_members(self):

limit = timedelta(hours=23, minutes=59)

self.assertEqual(timezone.utc.utcoffset(None), ZERO)

self.assertEqual(timezone.min.utcoffset(None), -limit)

self.assertEqual(timezone.max.utcoffset(None), limit)

def test_constructor(self):

self.assertIs(timezone.utc, timezone(timedelta(0)))

self.assertIsNot(timezone.utc, timezone(timedelta(0), 'UTC'))

self.assertEqual(timezone.utc, timezone(timedelta(0), 'UTC'))

# invalid offsets

for invalid in [timedelta(microseconds=1), timedelta(1, 1),

timedelta(seconds=1), timedelta(1), -timedelta(1)]:

self.assertRaises(ValueError, timezone, invalid)

self.assertRaises(ValueError, timezone, -invalid)

with self.assertRaises(TypeError): timezone(None)

with self.assertRaises(TypeError): timezone(42)

with self.assertRaises(TypeError): timezone(ZERO, None)

with self.assertRaises(TypeError): timezone(ZERO, 42)

with self.assertRaises(TypeError): timezone(ZERO, 'ABC', 'extra')

def test_inheritance(self):

self.assertIsInstance(timezone.utc, tzinfo)

self.assertIsInstance(self.EST, tzinfo)

def test_utcoffset(self):

dummy = self.DT

for h in [0, 1.5, 12]:

offset = h * HOUR

self.assertEqual(offset, timezone(offset).utcoffset(dummy))

self.assertEqual(-offset, timezone(-offset).utcoffset(dummy))

with self.assertRaises(TypeError): self.EST.utcoffset('')

with self.assertRaises(TypeError): self.EST.utcoffset(5)

def test_dst(self):

self.assertIsNone(timezone.utc.dst(self.DT))

with self.assertRaises(TypeError): self.EST.dst('')

with self.assertRaises(TypeError): self.EST.dst(5)

def test_tzname(self):

self.assertEqual('UTC', timezone.utc.tzname(None))

self.assertEqual('UTC', timezone(ZERO).tzname(None))

self.assertEqual('UTC-05:00', timezone(-5 * HOUR).tzname(None))

self.assertEqual('UTC+09:30', timezone(9.5 * HOUR).tzname(None))

self.assertEqual('UTC-00:01', timezone(timedelta(minutes=-1)).tzname(None))

self.assertEqual('XYZ', timezone(-5 * HOUR, 'XYZ').tzname(None))

with self.assertRaises(TypeError): self.EST.tzname('')

with self.assertRaises(TypeError): self.EST.tzname(5)

def test_fromutc(self):

with self.assertRaises(ValueError):

timezone.utc.fromutc(self.DT)

with self.assertRaises(TypeError):

timezone.utc.fromutc('not datetime')

for tz in [self.EST, self.ACDT, Eastern]:

utctime = self.DT.replace(tzinfo=tz)

local = tz.fromutc(utctime)

self.assertEqual(local - utctime, tz.utcoffset(local))

self.assertEqual(local,

self.DT.replace(tzinfo=timezone.utc))

def test_comparison(self):

self.assertNotEqual(timezone(ZERO), timezone(HOUR))

self.assertEqual(timezone(HOUR), timezone(HOUR))

self.assertEqual(timezone(-5 * HOUR), timezone(-5 * HOUR, 'EST'))

with self.assertRaises(TypeError): timezone(ZERO) < timezone(ZERO)

self.assertIn(timezone(ZERO), {timezone(ZERO)})

self.assertTrue(timezone(ZERO) != None)

self.assertFalse(timezone(ZERO) == None)

def test_aware_datetime(self):

# test that timezone instances can be used by datetime

t = datetime(1, 1, 1)

for tz in [timezone.min, timezone.max, timezone.utc]:

self.assertEqual(tz.tzname(t),

t.replace(tzinfo=tz).tzname())

self.assertEqual(tz.utcoffset(t),

t.replace(tzinfo=tz).utcoffset())

self.assertEqual(tz.dst(t),

t.replace(tzinfo=tz).dst())

def test_pickle(self):

for tz in self.ACDT, self.EST, timezone.min, timezone.max:

for pickler, unpickler, proto in pickle_choices:

tz_copy = unpickler.loads(pickler.dumps(tz, proto))

self.assertEqual(tz_copy, tz)

tz = timezone.utc

for pickler, unpickler, proto in pickle_choices:

tz_copy = unpickler.loads(pickler.dumps(tz, proto))

self.assertIs(tz_copy, tz)

def test_copy(self):

for tz in self.ACDT, self.EST, timezone.min, timezone.max:

tz_copy = copy.copy(tz)

self.assertEqual(tz_copy, tz)

tz = timezone.utc

tz_copy = copy.copy(tz)

self.assertIs(tz_copy, tz)

def test_deepcopy(self):

for tz in self.ACDT, self.EST, timezone.min, timezone.max:

tz_copy = copy.deepcopy(tz)

self.assertEqual(tz_copy, tz)

tz = timezone.utc

tz_copy = copy.deepcopy(tz)

self.assertIs(tz_copy, tz)

#############################################################################

# Base class for testing a particular aspect of timedelta, time, date and

# datetime comparisons.

class HarmlessMixedComparison:

# Test that __eq__ and __ne__ don't complain for mixed-type comparisons.

# Subclasses must define 'theclass', and theclass(1, 1, 1) must be a

# legit constructor.

def test_harmless_mixed_comparison(self):

me = self.theclass(1, 1, 1)

self.assertFalse(me == ())

self.assertTrue(me != ())

self.assertFalse(() == me)

self.assertTrue(() != me)

self.assertIn(me, [1, 20, [], me])

self.assertIn([], [me, 1, 20, []])

def test_harmful_mixed_comparison(self):

me = self.theclass(1, 1, 1)

self.assertRaises(TypeError, lambda: me < ())

self.assertRaises(TypeError, lambda: me <= ())

self.assertRaises(TypeError, lambda: me > ())

self.assertRaises(TypeError, lambda: me >= ())

self.assertRaises(TypeError, lambda: () < me)

self.assertRaises(TypeError, lambda: () <= me)

self.assertRaises(TypeError, lambda: () > me)

self.assertRaises(TypeError, lambda: () >= me)

#############################################################################

# timedelta tests

class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):

theclass = timedelta

def test_constructor(self):

eq = self.assertEqual

td = timedelta

# Check keyword args to constructor

eq(td(), td(weeks=0, days=0, hours=0, minutes=0, seconds=0,

milliseconds=0, microseconds=0))

eq(td(1), td(days=1))

eq(td(0, 1), td(seconds=1))

eq(td(0, 0, 1), td(microseconds=1))

eq(td(weeks=1), td(days=7))

eq(td(days=1), td(hours=24))

eq(td(hours=1), td(minutes=60))

eq(td(minutes=1), td(seconds=60))

eq(td(seconds=1), td(milliseconds=1000))

eq(td(milliseconds=1), td(microseconds=1000))

# Check float args to constructor

eq(td(weeks=1.0/7), td(days=1))

eq(td(days=1.0/24), td(hours=1))

eq(td(hours=1.0/60), td(minutes=1))

eq(td(minutes=1.0/60), td(seconds=1))

eq(td(seconds=0.001), td(milliseconds=1))

eq(td(milliseconds=0.001), td(microseconds=1))

def test_computations(self):

eq = self.assertEqual

td = timedelta

a = td(7) # One week

b = td(0, 60) # One minute

c = td(0, 0, 1000) # One millisecond

eq(a+b+c, td(7, 60, 1000))

eq(a-b, td(6, 24*3600 - 60))

eq(b.__rsub__(a), td(6, 24*3600 - 60))

eq(-a, td(-7))

eq(+a, td(7))

eq(-b, td(-1, 24*3600 - 60))

eq(-c, td(-1, 24*3600 - 1, 999000))

eq(abs(a), a)

eq(abs(-a), a)

eq(td(6, 24*3600), a)

eq(td(0, 0, 60*1000000), b)

eq(a*10, td(70))

eq(a*10, 10*a)

eq(a*10, 10*a)

eq(b*10, td(0, 600))

eq(10*b, td(0, 600))

eq(b*10, td(0, 600))

eq(c*10, td(0, 0, 10000))

eq(10*c, td(0, 0, 10000))

eq(c*10, td(0, 0, 10000))

eq(a*-1, -a)

eq(b*-2, -b-b)

eq(c*-2, -c+-c)

eq(b*(60*24), (b*60)*24)

eq(b*(60*24), (60*b)*24)

eq(c*1000, td(0, 1))

eq(1000*c, td(0, 1))

eq(a//7, td(1))

eq(b//10, td(0, 6))

eq(c//1000, td(0, 0, 1))

eq(a//10, td(0, 7*24*360))

eq(a//3600000, td(0, 0, 7*24*1000))

eq(a/0.5, td(14))

eq(b/0.5, td(0, 120))

eq(a/7, td(1))

eq(b/10, td(0, 6))

eq(c/1000, td(0, 0, 1))

eq(a/10, td(0, 7*24*360))

eq(a/3600000, td(0, 0, 7*24*1000))

# Multiplication by float

us = td(microseconds=1)

eq((3*us) * 0.5, 2*us)

eq((5*us) * 0.5, 2*us)

eq(0.5 * (3*us), 2*us)

eq(0.5 * (5*us), 2*us)

eq((-3*us) * 0.5, -2*us)

eq((-5*us) * 0.5, -2*us)

# Issue #23521

eq(td(seconds=1) * 0.123456, td(microseconds=123456))

eq(td(seconds=1) * 0.6112295, td(microseconds=611229))

# Division by int and float

eq((3*us) / 2, 2*us)

eq((5*us) / 2, 2*us)

eq((-3*us) / 2.0, -2*us)

eq((-5*us) / 2.0, -2*us)

eq((3*us) / -2, -2*us)

eq((5*us) / -2, -2*us)

eq((3*us) / -2.0, -2*us)

eq((5*us) / -2.0, -2*us)

for i in range(-10, 10):

eq((i*us/3)//us, round(i/3))

for i in range(-10, 10):

eq((i*us/-3)//us, round(i/-3))

# Issue #23521

eq(td(seconds=1) / (1 / 0.6112295), td(microseconds=611229))

# Issue #11576

eq(td(999999999, 86399, 999999) - td(999999999, 86399, 999998),

td(0, 0, 1))

eq(td(999999999, 1, 1) - td(999999999, 1, 0),

td(0, 0, 1))

def test_disallowed_computations(self):

a = timedelta(42)

# Add/sub ints or floats should be illegal

for i in 1, 1.0:

self.assertRaises(TypeError, lambda: a+i)

self.assertRaises(TypeError, lambda: a-i)

self.assertRaises(TypeError, lambda: i+a)

self.assertRaises(TypeError, lambda: i-a)

# Division of int by timedelta doesn't make sense.

# Division by zero doesn't make sense.

zero = 0

self.assertRaises(TypeError, lambda: zero // a)

self.assertRaises(ZeroDivisionError, lambda: a // zero)

self.assertRaises(ZeroDivisionError, lambda: a / zero)

self.assertRaises(ZeroDivisionError, lambda: a / 0.0)

self.assertRaises(TypeError, lambda: a / '')

@support.requires_IEEE_754

def test_disallowed_special(self):

a = timedelta(42)

self.assertRaises(ValueError, a.__mul__, NAN)

self.assertRaises(ValueError, a.__truediv__, NAN)

def test_basic_attributes(self):

days, seconds, us = 1, 7, 31

td = timedelta(days, seconds, us)

self.assertEqual(td.days, days)

self.assertEqual(td.seconds, seconds)

self.assertEqual(td.microseconds, us)

def test_total_seconds(self):

td = timedelta(days=365)

self.assertEqual(td.total_seconds(), 31536000.0)

for total_seconds in [123456.789012, -123456.789012, 0.123456, 0, 1e6]:

td = timedelta(seconds=total_seconds)

self.assertEqual(td.total_seconds(), total_seconds)

# Issue8644: Test that td.total_seconds() has the same

# accuracy as td / timedelta(seconds=1).

for ms in [-1, -2, -123]:

td = timedelta(microseconds=ms)

self.assertEqual(td.total_seconds(), td / timedelta(seconds=1))

def test_carries(self):

t1 = timedelta(days=100,

weeks=-7,

hours=-24*(100-49),

minutes=-3,

seconds=12,

microseconds=(3*60 - 12) * 1e6 + 1)

t2 = timedelta(microseconds=1)

self.assertEqual(t1, t2)

def test_hash_equality(self):

t1 = timedelta(days=100,

weeks=-7,

hours=-24*(100-49),

minutes=-3,

seconds=12,

microseconds=(3*60 - 12) * 1000000)

t2 = timedelta()

self.assertEqual(hash(t1), hash(t2))

t1 += timedelta(weeks=7)

t2 += timedelta(days=7*7)

self.assertEqual(t1, t2)

self.assertEqual(hash(t1), hash(t2))

d = {t1: 1}

d[t2] = 2

self.assertEqual(len(d), 1)

self.assertEqual(d[t1], 2)

def test_pickling(self):

args = 12, 34, 56

orig = timedelta(*args)

for pickler, unpickler, proto in pickle_choices:

green = pickler.dumps(orig, proto)

derived = unpickler.loads(green)

self.assertEqual(orig, derived)

def test_compare(self):

t1 = timedelta(2, 3, 4)

t2 = timedelta(2, 3, 4)

self.assertEqual(t1, t2)

self.assertTrue(t1 <= t2)

self.assertTrue(t1 >= t2)

self.assertFalse(t1 != t2)

self.assertFalse(t1 < t2)

self.assertFalse(t1 > t2)

for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):

t2 = timedelta(*args) # this is larger than t1

self.assertTrue(t1 < t2)

self.assertTrue(t2 > t1)

self.assertTrue(t1 <= t2)

self.assertTrue(t2 >= t1)

self.assertTrue(t1 != t2)

self.assertTrue(t2 != t1)

self.assertFalse(t1 == t2)

self.assertFalse(t2 == t1)

self.assertFalse(t1 > t2)

self.assertFalse(t2 < t1)

self.assertFalse(t1 >= t2)

self.assertFalse(t2 <= t1)

for badarg in OTHERSTUFF:

self.assertEqual(t1 == badarg, False)

self.assertEqual(t1 != badarg, True)

self.assertEqual(badarg == t1, False)

self.assertEqual(badarg != t1, True)

self.assertRaises(TypeError, lambda: t1 <= badarg)

self.assertRaises(TypeError, lambda: t1 < badarg)

self.assertRaises(TypeError, lambda: t1 > badarg)

self.assertRaises(TypeError, lambda: t1 >= badarg)

self.assertRaises(TypeError, lambda: badarg <= t1)

self.assertRaises(TypeError, lambda: badarg < t1)

self.assertRaises(TypeError, lambda: badarg > t1)

self.assertRaises(TypeError, lambda: badarg >= t1)

def test_str(self):

td = timedelta

eq = self.assertEqual

eq(str(td(1)), "1 day, 0:00:00")

eq(str(td(-1)), "-1 day, 0:00:00")

eq(str(td(2)), "2 days, 0:00:00")

eq(str(td(-2)), "-2 days, 0:00:00")

eq(str(td(hours=12, minutes=58, seconds=59)), "12:58:59")

eq(str(td(hours=2, minutes=3, seconds=4)), "2:03:04")

eq(str(td(weeks=-30, hours=23, minutes=12, seconds=34)),

"-210 days, 23:12:34")

eq(str(td(milliseconds=1)), "0:00:00.001000")

eq(str(td(microseconds=3)), "0:00:00.000003")

eq(str(td(days=999999999, hours=23, minutes=59, seconds=59,

microseconds=999999)),

"999999999 days, 23:59:59.999999")

def test_repr(self):

name = 'datetime.' + self.theclass.__name__

self.assertEqual(repr(self.theclass(1)),

"%s(1)" % name)

self.assertEqual(repr(self.theclass(10, 2)),

"%s(10, 2)" % name)

self.assertEqual(repr(self.theclass(-10, 2, 400000)),

"%s(-10, 2, 400000)" % name)

def test_roundtrip(self):

for td in (timedelta(days=999999999, hours=23, minutes=59,

seconds=59, microseconds=999999),

timedelta(days=-999999999),

timedelta(days=-999999999, seconds=1),

timedelta(days=1, seconds=2, microseconds=3)):

# Verify td -> string -> td identity.

s = repr(td)

self.assertTrue(s.startswith('datetime.'))

s = s[9:]

td2 = eval(s)

self.assertEqual(td, td2)

# Verify identity via reconstructing from pieces.

td2 = timedelta(td.days, td.seconds, td.microseconds)

self.assertEqual(td, td2)

def test_resolution_info(self):

self.assertIsInstance(timedelta.min, timedelta)

self.assertIsInstance(timedelta.max, timedelta)

self.assertIsInstance(timedelta.resolution, timedelta)

self.assertTrue(timedelta.max > timedelta.min)

self.assertEqual(timedelta.min, timedelta(-999999999))

self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))

self.assertEqual(timedelta.resolution, timedelta(0, 0, 1))

def test_overflow(self):

tiny = timedelta.resolution

td = timedelta.min + tiny

td -= tiny # no problem

self.assertRaises(OverflowError, td.__sub__, tiny)

self.assertRaises(OverflowError, td.__add__, -tiny)

td = timedelta.max - tiny

td += tiny # no problem

self.assertRaises(OverflowError, td.__add__, tiny)

self.assertRaises(OverflowError, td.__sub__, -tiny)

self.assertRaises(OverflowError, lambda: -timedelta.max)

day = timedelta(1)

self.assertRaises(OverflowError, day.__mul__, 10**9)

self.assertRaises(OverflowError, day.__mul__, 1e9)

self.assertRaises(OverflowError, day.__truediv__, 1e-20)

self.assertRaises(OverflowError, day.__truediv__, 1e-10)

self.assertRaises(OverflowError, day.__truediv__, 9e-10)

@support.requires_IEEE_754

def _test_overflow_special(self):

day = timedelta(1)

self.assertRaises(OverflowError, day.__mul__, INF)

self.assertRaises(OverflowError, day.__mul__, -INF)

def test_microsecond_rounding(self):

td = timedelta

eq = self.assertEqual

# Single-field rounding.

eq(td(milliseconds=0.4/1000), td(0)) # rounds to 0

eq(td(milliseconds=-0.4/1000), td(0)) # rounds to 0

eq(td(milliseconds=0.5/1000), td(microseconds=0))

eq(td(milliseconds=-0.5/1000), td(microseconds=-0))

eq(td(milliseconds=0.6/1000), td(microseconds=1))

eq(td(milliseconds=-0.6/1000), td(microseconds=-1))

eq(td(milliseconds=1.5/1000), td(microseconds=2))

eq(td(milliseconds=-1.5/1000), td(microseconds=-2))

eq(td(seconds=0.5/10**6), td(microseconds=0))

eq(td(seconds=-0.5/10**6), td(microseconds=-0))

eq(td(seconds=1/2**7), td(microseconds=7812))

eq(td(seconds=-1/2**7), td(microseconds=-7812))

# Rounding due to contributions from more than one field.

us_per_hour = 3600e6

us_per_day = us_per_hour * 24

eq(td(days=.4/us_per_day), td(0))

eq(td(hours=.2/us_per_hour), td(0))

eq(td(days=.4/us_per_day, hours=.2/us_per_hour), td(microseconds=1))

eq(td(days=-.4/us_per_day), td(0))

eq(td(hours=-.2/us_per_hour), td(0))

eq(td(days=-.4/us_per_day, hours=-.2/us_per_hour), td(microseconds=-1))

# Test for a patch in Issue 8860

eq(td(microseconds=0.5), 0.5*td(microseconds=1.0))

eq(td(microseconds=0.5)//td.resolution, 0.5*td.resolution//td.resolution)

def test_massive_normalization(self):

td = timedelta(microseconds=-1)

self.assertEqual((td.days, td.seconds, td.microseconds),

(-1, 24*3600-1, 999999))

def test_bool(self):

self.assertTrue(timedelta(1))

self.assertTrue(timedelta(0, 1))

self.assertTrue(timedelta(0, 0, 1))

self.assertTrue(timedelta(microseconds=1))

self.assertFalse(timedelta(0))

def test_subclass_timedelta(self):

class T(timedelta):

@staticmethod

def from_td(td):

return T(td.days, td.seconds, td.microseconds)

def as_hours(self):

sum = (self.days * 24 +

self.seconds / 3600.0 +

self.microseconds / 3600e6)

return round(sum)

t1 = T(days=1)

self.assertIs(type(t1), T)

self.assertEqual(t1.as_hours(), 24)

t2 = T(days=-1, seconds=-3600)

self.assertIs(type(t2), T)

self.assertEqual(t2.as_hours(), -25)

t3 = t1 + t2

self.assertIs(type(t3), timedelta)

t4 = T.from_td(t3)

self.assertIs(type(t4), T)

self.assertEqual(t3.days, t4.days)

self.assertEqual(t3.seconds, t4.seconds)

self.assertEqual(t3.microseconds, t4.microseconds)

self.assertEqual(str(t3), str(t4))

self.assertEqual(t4.as_hours(), -1)

def test_division(self):

t = timedelta(hours=1, minutes=24, seconds=19)

second = timedelta(seconds=1)

self.assertEqual(t / second, 5059.0)

self.assertEqual(t // second, 5059)

t = timedelta(minutes=2, seconds=30)

minute = timedelta(minutes=1)

self.assertEqual(t / minute, 2.5)

self.assertEqual(t // minute, 2)

zerotd = timedelta(0)

self.assertRaises(ZeroDivisionError, truediv, t, zerotd)

self.assertRaises(ZeroDivisionError, floordiv, t, zerotd)

# self.assertRaises(TypeError, truediv, t, 2)

# note: floor division of a timedelta by an integer *is*

# currently permitted.

def test_remainder(self):

t = timedelta(minutes=2, seconds=30)

minute = timedelta(minutes=1)

r = t % minute

self.assertEqual(r, timedelta(seconds=30))

t = timedelta(minutes=-2, seconds=30)

r = t % minute

self.assertEqual(r, timedelta(seconds=30))

zerotd = timedelta(0)

self.assertRaises(ZeroDivisionError, mod, t, zerotd)

self.assertRaises(TypeError, mod, t, 10)

def test_divmod(self):

t = timedelta(minutes=2, seconds=30)

minute = timedelta(minutes=1)

q, r = divmod(t, minute)

self.assertEqual(q, 2)

self.assertEqual(r, timedelta(seconds=30))

t = timedelta(minutes=-2, seconds=30)

q, r = divmod(t, minute)

self.assertEqual(q, -2)

self.assertEqual(r, timedelta(seconds=30))

zerotd = timedelta(0)

self.assertRaises(ZeroDivisionError, divmod, t, zerotd)

self.assertRaises(TypeError, divmod, t, 10)

#############################################################################

# date tests

class TestDateOnly(unittest.TestCase):

# Tests here won't pass if also run on datetime objects, so don't

# subclass this to test datetimes too.

def test_delta_non_days_ignored(self):

dt = date(2000, 1, 2)

delta = timedelta(days=1, hours=2, minutes=3, seconds=4,

microseconds=5)

days = timedelta(delta.days)

self.assertEqual(days, timedelta(1))

dt2 = dt + delta

self.assertEqual(dt2, dt + days)

dt2 = delta + dt

self.assertEqual(dt2, dt + days)

dt2 = dt - delta

self.assertEqual(dt2, dt - days)

delta = -delta

days = timedelta(delta.days)

self.assertEqual(days, timedelta(-2))

dt2 = dt + delta

self.assertEqual(dt2, dt + days)

dt2 = delta + dt

self.assertEqual(dt2, dt + days)

dt2 = dt - delta

self.assertEqual(dt2, dt - days)

class SubclassDate(date):

sub_var = 1

class TestDate(HarmlessMixedComparison, unittest.TestCase):

# Tests here should pass for both dates and datetimes, except for a

# few tests that TestDateTime overrides.

theclass = date

def test_basic_attributes(self):

dt = self.theclass(2002, 3, 1)

self.assertEqual(dt.year, 2002)

self.assertEqual(dt.month, 3)

self.assertEqual(dt.day, 1)

def test_roundtrip(self):

for dt in (self.theclass(1, 2, 3),

self.theclass.today()):

# Verify dt -> string -> date identity.

s = repr(dt)

self.assertTrue(s.startswith('datetime.'))

s = s[9:]

dt2 = eval(s)

self.assertEqual(dt, dt2)

# Verify identity via reconstructing from pieces.

dt2 = self.theclass(dt.year, dt.month, dt.day)

self.assertEqual(dt, dt2)

def test_ordinal_conversions(self):

# Check some fixed values.

for y, m, d, n in [(1, 1, 1, 1), # calendar origin

(1, 12, 31, 365),

(2, 1, 1, 366),

# first example from "Calendrical Calculations"

(1945, 11, 12, 710347)]:

d = self.theclass(y, m, d)

self.assertEqual(n, d.toordinal())

fromord = self.theclass.fromordinal(n)

self.assertEqual(d, fromord)

if hasattr(fromord, "hour"):

# if we're checking something fancier than a date, verify

# the extra fields have been zeroed out

self.assertEqual(fromord.hour, 0)

self.assertEqual(fromord.minute, 0)

self.assertEqual(fromord.second, 0)

self.assertEqual(fromord.microsecond, 0)

# Check first and last days of year spottily across the whole

# range of years supported.

for year in range(MINYEAR, MAXYEAR+1, 7):

# Verify (year, 1, 1) -> ordinal -> y, m, d is identity.

d = self.theclass(year, 1, 1)

n = d.toordinal()

d2 = self.theclass.fromordinal(n)

self.assertEqual(d, d2)

# Verify that moving back a day gets to the end of year-1.

if year > 1:

d = self.theclass.fromordinal(n-1)

d2 = self.theclass(year-1, 12, 31)

self.assertEqual(d, d2)

self.assertEqual(d2.toordinal(), n-1)

# Test every day in a leap-year and a non-leap year.

dim = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

for year, isleap in (2000, True), (2002, False):

n = self.theclass(year, 1, 1).toordinal()

for month, maxday in zip(range(1, 13), dim):

if month == 2 and isleap:

maxday += 1

for day in range(1, maxday+1):

d = self.theclass(year, month, day)

self.assertEqual(d.toordinal(), n)

self.assertEqual(d, self.theclass.fromordinal(n))

n += 1

def test_extreme_ordinals(self):

a = self.theclass.min

a = self.theclass(a.year, a.month, a.day) # get rid of time parts

aord = a.toordinal()

b = a.fromordinal(aord)

self.assertEqual(a, b)

self.assertRaises(ValueError, lambda: a.fromordinal(aord - 1))

b = a + timedelta(days=1)

self.assertEqual(b.toordinal(), aord + 1)

self.assertEqual(b, self.theclass.fromordinal(aord + 1))

a = self.theclass.max

a = self.theclass(a.year, a.month, a.day) # get rid of time parts

aord = a.toordinal()

b = a.fromordinal(aord)

self.assertEqual(a, b)

self.assertRaises(ValueError, lambda: a.fromordinal(aord + 1))

b = a - timedelta(days=1)

self.assertEqual(b.toordinal(), aord - 1)

self.assertEqual(b, self.theclass.fromordinal(aord - 1))

def test_bad_constructor_arguments(self):

# bad years

self.theclass(MINYEAR, 1, 1) # no exception

self.theclass(MAXYEAR, 1, 1) # no exception

self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)

self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)

# bad months

self.theclass(2000, 1, 1) # no exception

self.theclass(2000, 12, 1) # no exception

self.assertRaises(ValueError, self.theclass, 2000, 0, 1)

self.assertRaises(ValueError, self.theclass, 2000, 13, 1)

# bad days

self.theclass(2000, 2, 29) # no exception

self.theclass(2004, 2, 29) # no exception

self.theclass(2400, 2, 29) # no exception

self.assertRaises(ValueError, self.theclass, 2000, 2, 30)