"""Test date/time type.

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

"""

import os

import sys

import pickle

import cPickle

import unittest

from test import test_support

from datetime import MINYEAR, MAXYEAR

from datetime import timedelta

from datetime import tzinfo

from datetime import time

from datetime import date, datetime

pickle_choices = [(pickler, unpickler, proto)

                  for pickler in pickle, cPickle

                  for unpickler in pickle, cPickle

                  for proto in range(3)]

assert len(pickle_choices) == 2*2*3

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

# mixed-type comparisons.

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

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

# module tests

class TestModule(unittest.TestCase):

    def test_constants(self):

        import datetime

        self.assertEqual(datetime.MINYEAR, 1)

        self.assertEqual(datetime.MAXYEAR, 9999)

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

# 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)

class TestTZInfo(unittest.TestCase):

    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.failUnless(issubclass(NotEnough, tzinfo))

        ne = NotEnough(3, "NotByALongShot")

        self.failUnless(isinstance(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.failUnless(isinstance(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.failUnless(type(orig) is tzinfo)

        for pickler, unpickler, proto in pickle_choices:

            green = pickler.dumps(orig, proto)

            derived = unpickler.loads(green)

            self.failUnless(type(derived) is tzinfo)

    def test_pickling_subclass(self):

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

        offset = timedelta(minutes=-300)

        orig = PicklableFixedOffset(offset, 'cookie')

        self.failUnless(isinstance(orig, tzinfo))

        self.failUnless(type(orig) is PicklableFixedOffset)

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

        self.assertEqual(orig.tzname(None), 'cookie')

        for pickler, unpickler, proto in pickle_choices:

            green = pickler.dumps(orig, proto)

            derived = unpickler.loads(green)

            self.failUnless(isinstance(derived, tzinfo))

            self.failUnless(type(derived) is PicklableFixedOffset)

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

            self.assertEqual(derived.tzname(None), 'cookie')

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

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

# datetime comparisons.

class HarmlessMixedComparison(unittest.TestCase):

    # 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.failIf(me == ())

        self.failUnless(me != ())

        self.failIf(() == me)

        self.failUnless(() != me)

        self.failUnless(me in [1, 20L, [], me])

        self.failIf(me not in [1, 20L, [], me])

        self.failUnless([] in [me, 1, 20L, []])

        self.failIf([] not in [me, 1, 20L, []])

    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)

        self.assertRaises(TypeError, cmp, (), me)

        self.assertRaises(TypeError, cmp, me, ())

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

# timedelta tests

class TestTimeDelta(HarmlessMixedComparison):

    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(-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*10L, 10*a)

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

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

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

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

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

        eq(c*10L, 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))

    def test_disallowed_computations(self):

        a = timedelta(42)

        # Add/sub ints, longs, floats should be illegal

        for i in 1, 1L, 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)

        # Mul/div by float isn't supported.

        x = 2.3

        self.assertRaises(TypeError, lambda: a*x)

        self.assertRaises(TypeError, lambda: x*a)

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

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

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

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

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

        # Division by zero doesn't make sense.

        for zero in 0, 0L:

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

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

    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_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.failUnless(t1 == t2)

        self.failUnless(t1 <= t2)

        self.failUnless(t1 >= t2)

        self.failUnless(not t1 != t2)

        self.failUnless(not t1 < t2)

        self.failUnless(not t1 > t2)

        self.assertEqual(cmp(t1, t2), 0)

        self.assertEqual(cmp(t2, t1), 0)

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

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

            self.failUnless(t1 < t2)

            self.failUnless(t2 > t1)

            self.failUnless(t1 <= t2)

            self.failUnless(t2 >= t1)

            self.failUnless(t1 != t2)

            self.failUnless(t2 != t1)

            self.failUnless(not t1 == t2)

            self.failUnless(not t2 == t1)

            self.failUnless(not t1 > t2)

            self.failUnless(not t2 < t1)

            self.failUnless(not t1 >= t2)

            self.failUnless(not t2 <= t1)

            self.assertEqual(cmp(t1, t2), -1)

            self.assertEqual(cmp(t2, t1), 1)

        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_roundtrip(self):

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

                             seconds=59, microseconds=999999),

                   timedelta(days=-999999999),

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

            # Verify td -> string -> td identity.

            s = repr(td)

            self.failUnless(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.assert_(isinstance(timedelta.min, timedelta))

        self.assert_(isinstance(timedelta.max, timedelta))

        self.assert_(isinstance(timedelta.resolution, timedelta))

        self.assert_(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)

    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.6/1000), td(microseconds=1))

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

        # 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))

    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.failUnless(timedelta(1))

        self.failUnless(timedelta(0, 1))

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

        self.failUnless(timedelta(microseconds=1))

        self.failUnless(not 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.assert_(type(t1) is T)

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

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

        self.assert_(type(t2) is T)

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

        t3 = t1 + t2

        self.assert_(type(t3) is timedelta)

        t4 = T.from_td(t3)

        self.assert_(type(t4) is 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)

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

# 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):

    # 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):