+++ /dev/null
-"""Test date/time type.\r
-\r
-See http://www.zope.org/Members/fdrake/DateTimeWiki/TestCases\r
-"""\r
-from __future__ import division\r
-import sys\r
-import pickle\r
-import cPickle\r
-import unittest\r
-\r
-from test import test_support\r
-\r
-from datetime import MINYEAR, MAXYEAR\r
-from datetime import timedelta\r
-from datetime import tzinfo\r
-from datetime import time\r
-from datetime import date, datetime\r
-\r
-pickle_choices = [(pickler, unpickler, proto)\r
- for pickler in pickle, cPickle\r
- for unpickler in pickle, cPickle\r
- for proto in range(3)]\r
-assert len(pickle_choices) == 2*2*3\r
-\r
-# An arbitrary collection of objects of non-datetime types, for testing\r
-# mixed-type comparisons.\r
-OTHERSTUFF = (10, 10L, 34.5, "abc", {}, [], ())\r
-\r
-\r
-#############################################################################\r
-# module tests\r
-\r
-class TestModule(unittest.TestCase):\r
-\r
- def test_constants(self):\r
- import datetime\r
- self.assertEqual(datetime.MINYEAR, 1)\r
- self.assertEqual(datetime.MAXYEAR, 9999)\r
-\r
-#############################################################################\r
-# tzinfo tests\r
-\r
-class FixedOffset(tzinfo):\r
- def __init__(self, offset, name, dstoffset=42):\r
- if isinstance(offset, int):\r
- offset = timedelta(minutes=offset)\r
- if isinstance(dstoffset, int):\r
- dstoffset = timedelta(minutes=dstoffset)\r
- self.__offset = offset\r
- self.__name = name\r
- self.__dstoffset = dstoffset\r
- def __repr__(self):\r
- return self.__name.lower()\r
- def utcoffset(self, dt):\r
- return self.__offset\r
- def tzname(self, dt):\r
- return self.__name\r
- def dst(self, dt):\r
- return self.__dstoffset\r
-\r
-class PicklableFixedOffset(FixedOffset):\r
- def __init__(self, offset=None, name=None, dstoffset=None):\r
- FixedOffset.__init__(self, offset, name, dstoffset)\r
-\r
-class TestTZInfo(unittest.TestCase):\r
-\r
- def test_non_abstractness(self):\r
- # In order to allow subclasses to get pickled, the C implementation\r
- # wasn't able to get away with having __init__ raise\r
- # NotImplementedError.\r
- useless = tzinfo()\r
- dt = datetime.max\r
- self.assertRaises(NotImplementedError, useless.tzname, dt)\r
- self.assertRaises(NotImplementedError, useless.utcoffset, dt)\r
- self.assertRaises(NotImplementedError, useless.dst, dt)\r
-\r
- def test_subclass_must_override(self):\r
- class NotEnough(tzinfo):\r
- def __init__(self, offset, name):\r
- self.__offset = offset\r
- self.__name = name\r
- self.assertTrue(issubclass(NotEnough, tzinfo))\r
- ne = NotEnough(3, "NotByALongShot")\r
- self.assertIsInstance(ne, tzinfo)\r
-\r
- dt = datetime.now()\r
- self.assertRaises(NotImplementedError, ne.tzname, dt)\r
- self.assertRaises(NotImplementedError, ne.utcoffset, dt)\r
- self.assertRaises(NotImplementedError, ne.dst, dt)\r
-\r
- def test_normal(self):\r
- fo = FixedOffset(3, "Three")\r
- self.assertIsInstance(fo, tzinfo)\r
- for dt in datetime.now(), None:\r
- self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))\r
- self.assertEqual(fo.tzname(dt), "Three")\r
- self.assertEqual(fo.dst(dt), timedelta(minutes=42))\r
-\r
- def test_pickling_base(self):\r
- # There's no point to pickling tzinfo objects on their own (they\r
- # carry no data), but they need to be picklable anyway else\r
- # concrete subclasses can't be pickled.\r
- orig = tzinfo.__new__(tzinfo)\r
- self.assertTrue(type(orig) is tzinfo)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertTrue(type(derived) is tzinfo)\r
-\r
- def test_pickling_subclass(self):\r
- # Make sure we can pickle/unpickle an instance of a subclass.\r
- offset = timedelta(minutes=-300)\r
- orig = PicklableFixedOffset(offset, 'cookie')\r
- self.assertIsInstance(orig, tzinfo)\r
- self.assertTrue(type(orig) is PicklableFixedOffset)\r
- self.assertEqual(orig.utcoffset(None), offset)\r
- self.assertEqual(orig.tzname(None), 'cookie')\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertIsInstance(derived, tzinfo)\r
- self.assertTrue(type(derived) is PicklableFixedOffset)\r
- self.assertEqual(derived.utcoffset(None), offset)\r
- self.assertEqual(derived.tzname(None), 'cookie')\r
-\r
-#############################################################################\r
-# Base clase for testing a particular aspect of timedelta, time, date and\r
-# datetime comparisons.\r
-\r
-class HarmlessMixedComparison:\r
- # Test that __eq__ and __ne__ don't complain for mixed-type comparisons.\r
-\r
- # Subclasses must define 'theclass', and theclass(1, 1, 1) must be a\r
- # legit constructor.\r
-\r
- def test_harmless_mixed_comparison(self):\r
- me = self.theclass(1, 1, 1)\r
-\r
- self.assertFalse(me == ())\r
- self.assertTrue(me != ())\r
- self.assertFalse(() == me)\r
- self.assertTrue(() != me)\r
-\r
- self.assertIn(me, [1, 20L, [], me])\r
- self.assertIn([], [me, 1, 20L, []])\r
-\r
- def test_harmful_mixed_comparison(self):\r
- me = self.theclass(1, 1, 1)\r
-\r
- self.assertRaises(TypeError, lambda: me < ())\r
- self.assertRaises(TypeError, lambda: me <= ())\r
- self.assertRaises(TypeError, lambda: me > ())\r
- self.assertRaises(TypeError, lambda: me >= ())\r
-\r
- self.assertRaises(TypeError, lambda: () < me)\r
- self.assertRaises(TypeError, lambda: () <= me)\r
- self.assertRaises(TypeError, lambda: () > me)\r
- self.assertRaises(TypeError, lambda: () >= me)\r
-\r
- self.assertRaises(TypeError, cmp, (), me)\r
- self.assertRaises(TypeError, cmp, me, ())\r
-\r
-#############################################################################\r
-# timedelta tests\r
-\r
-class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):\r
-\r
- theclass = timedelta\r
-\r
- def test_constructor(self):\r
- eq = self.assertEqual\r
- td = timedelta\r
-\r
- # Check keyword args to constructor\r
- eq(td(), td(weeks=0, days=0, hours=0, minutes=0, seconds=0,\r
- milliseconds=0, microseconds=0))\r
- eq(td(1), td(days=1))\r
- eq(td(0, 1), td(seconds=1))\r
- eq(td(0, 0, 1), td(microseconds=1))\r
- eq(td(weeks=1), td(days=7))\r
- eq(td(days=1), td(hours=24))\r
- eq(td(hours=1), td(minutes=60))\r
- eq(td(minutes=1), td(seconds=60))\r
- eq(td(seconds=1), td(milliseconds=1000))\r
- eq(td(milliseconds=1), td(microseconds=1000))\r
-\r
- # Check float args to constructor\r
- eq(td(weeks=1.0/7), td(days=1))\r
- eq(td(days=1.0/24), td(hours=1))\r
- eq(td(hours=1.0/60), td(minutes=1))\r
- eq(td(minutes=1.0/60), td(seconds=1))\r
- eq(td(seconds=0.001), td(milliseconds=1))\r
- eq(td(milliseconds=0.001), td(microseconds=1))\r
-\r
- def test_computations(self):\r
- eq = self.assertEqual\r
- td = timedelta\r
-\r
- a = td(7) # One week\r
- b = td(0, 60) # One minute\r
- c = td(0, 0, 1000) # One millisecond\r
- eq(a+b+c, td(7, 60, 1000))\r
- eq(a-b, td(6, 24*3600 - 60))\r
- eq(-a, td(-7))\r
- eq(+a, td(7))\r
- eq(-b, td(-1, 24*3600 - 60))\r
- eq(-c, td(-1, 24*3600 - 1, 999000))\r
- eq(abs(a), a)\r
- eq(abs(-a), a)\r
- eq(td(6, 24*3600), a)\r
- eq(td(0, 0, 60*1000000), b)\r
- eq(a*10, td(70))\r
- eq(a*10, 10*a)\r
- eq(a*10L, 10*a)\r
- eq(b*10, td(0, 600))\r
- eq(10*b, td(0, 600))\r
- eq(b*10L, td(0, 600))\r
- eq(c*10, td(0, 0, 10000))\r
- eq(10*c, td(0, 0, 10000))\r
- eq(c*10L, td(0, 0, 10000))\r
- eq(a*-1, -a)\r
- eq(b*-2, -b-b)\r
- eq(c*-2, -c+-c)\r
- eq(b*(60*24), (b*60)*24)\r
- eq(b*(60*24), (60*b)*24)\r
- eq(c*1000, td(0, 1))\r
- eq(1000*c, td(0, 1))\r
- eq(a//7, td(1))\r
- eq(b//10, td(0, 6))\r
- eq(c//1000, td(0, 0, 1))\r
- eq(a//10, td(0, 7*24*360))\r
- eq(a//3600000, td(0, 0, 7*24*1000))\r
-\r
- # Issue #11576\r
- eq(td(999999999, 86399, 999999) - td(999999999, 86399, 999998),\r
- td(0, 0, 1))\r
- eq(td(999999999, 1, 1) - td(999999999, 1, 0),\r
- td(0, 0, 1))\r
-\r
-\r
- def test_disallowed_computations(self):\r
- a = timedelta(42)\r
-\r
- # Add/sub ints, longs, floats should be illegal\r
- for i in 1, 1L, 1.0:\r
- self.assertRaises(TypeError, lambda: a+i)\r
- self.assertRaises(TypeError, lambda: a-i)\r
- self.assertRaises(TypeError, lambda: i+a)\r
- self.assertRaises(TypeError, lambda: i-a)\r
-\r
- # Mul/div by float isn't supported.\r
- x = 2.3\r
- self.assertRaises(TypeError, lambda: a*x)\r
- self.assertRaises(TypeError, lambda: x*a)\r
- self.assertRaises(TypeError, lambda: a/x)\r
- self.assertRaises(TypeError, lambda: x/a)\r
- self.assertRaises(TypeError, lambda: a // x)\r
- self.assertRaises(TypeError, lambda: x // a)\r
-\r
- # Division of int by timedelta doesn't make sense.\r
- # Division by zero doesn't make sense.\r
- for zero in 0, 0L:\r
- self.assertRaises(TypeError, lambda: zero // a)\r
- self.assertRaises(ZeroDivisionError, lambda: a // zero)\r
-\r
- def test_basic_attributes(self):\r
- days, seconds, us = 1, 7, 31\r
- td = timedelta(days, seconds, us)\r
- self.assertEqual(td.days, days)\r
- self.assertEqual(td.seconds, seconds)\r
- self.assertEqual(td.microseconds, us)\r
-\r
- def test_total_seconds(self):\r
- td = timedelta(days=365)\r
- self.assertEqual(td.total_seconds(), 31536000.0)\r
- for total_seconds in [123456.789012, -123456.789012, 0.123456, 0, 1e6]:\r
- td = timedelta(seconds=total_seconds)\r
- self.assertEqual(td.total_seconds(), total_seconds)\r
- # Issue8644: Test that td.total_seconds() has the same\r
- # accuracy as td / timedelta(seconds=1).\r
- for ms in [-1, -2, -123]:\r
- td = timedelta(microseconds=ms)\r
- self.assertEqual(td.total_seconds(),\r
- ((24*3600*td.days + td.seconds)*10**6\r
- + td.microseconds)/10**6)\r
-\r
- def test_carries(self):\r
- t1 = timedelta(days=100,\r
- weeks=-7,\r
- hours=-24*(100-49),\r
- minutes=-3,\r
- seconds=12,\r
- microseconds=(3*60 - 12) * 1e6 + 1)\r
- t2 = timedelta(microseconds=1)\r
- self.assertEqual(t1, t2)\r
-\r
- def test_hash_equality(self):\r
- t1 = timedelta(days=100,\r
- weeks=-7,\r
- hours=-24*(100-49),\r
- minutes=-3,\r
- seconds=12,\r
- microseconds=(3*60 - 12) * 1000000)\r
- t2 = timedelta()\r
- self.assertEqual(hash(t1), hash(t2))\r
-\r
- t1 += timedelta(weeks=7)\r
- t2 += timedelta(days=7*7)\r
- self.assertEqual(t1, t2)\r
- self.assertEqual(hash(t1), hash(t2))\r
-\r
- d = {t1: 1}\r
- d[t2] = 2\r
- self.assertEqual(len(d), 1)\r
- self.assertEqual(d[t1], 2)\r
-\r
- def test_pickling(self):\r
- args = 12, 34, 56\r
- orig = timedelta(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_compare(self):\r
- t1 = timedelta(2, 3, 4)\r
- t2 = timedelta(2, 3, 4)\r
- self.assertTrue(t1 == t2)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t1 >= t2)\r
- self.assertTrue(not t1 != t2)\r
- self.assertTrue(not t1 < t2)\r
- self.assertTrue(not t1 > t2)\r
- self.assertEqual(cmp(t1, t2), 0)\r
- self.assertEqual(cmp(t2, t1), 0)\r
-\r
- for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):\r
- t2 = timedelta(*args) # this is larger than t1\r
- self.assertTrue(t1 < t2)\r
- self.assertTrue(t2 > t1)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t2 >= t1)\r
- self.assertTrue(t1 != t2)\r
- self.assertTrue(t2 != t1)\r
- self.assertTrue(not t1 == t2)\r
- self.assertTrue(not t2 == t1)\r
- self.assertTrue(not t1 > t2)\r
- self.assertTrue(not t2 < t1)\r
- self.assertTrue(not t1 >= t2)\r
- self.assertTrue(not t2 <= t1)\r
- self.assertEqual(cmp(t1, t2), -1)\r
- self.assertEqual(cmp(t2, t1), 1)\r
-\r
- for badarg in OTHERSTUFF:\r
- self.assertEqual(t1 == badarg, False)\r
- self.assertEqual(t1 != badarg, True)\r
- self.assertEqual(badarg == t1, False)\r
- self.assertEqual(badarg != t1, True)\r
-\r
- self.assertRaises(TypeError, lambda: t1 <= badarg)\r
- self.assertRaises(TypeError, lambda: t1 < badarg)\r
- self.assertRaises(TypeError, lambda: t1 > badarg)\r
- self.assertRaises(TypeError, lambda: t1 >= badarg)\r
- self.assertRaises(TypeError, lambda: badarg <= t1)\r
- self.assertRaises(TypeError, lambda: badarg < t1)\r
- self.assertRaises(TypeError, lambda: badarg > t1)\r
- self.assertRaises(TypeError, lambda: badarg >= t1)\r
-\r
- def test_str(self):\r
- td = timedelta\r
- eq = self.assertEqual\r
-\r
- eq(str(td(1)), "1 day, 0:00:00")\r
- eq(str(td(-1)), "-1 day, 0:00:00")\r
- eq(str(td(2)), "2 days, 0:00:00")\r
- eq(str(td(-2)), "-2 days, 0:00:00")\r
-\r
- eq(str(td(hours=12, minutes=58, seconds=59)), "12:58:59")\r
- eq(str(td(hours=2, minutes=3, seconds=4)), "2:03:04")\r
- eq(str(td(weeks=-30, hours=23, minutes=12, seconds=34)),\r
- "-210 days, 23:12:34")\r
-\r
- eq(str(td(milliseconds=1)), "0:00:00.001000")\r
- eq(str(td(microseconds=3)), "0:00:00.000003")\r
-\r
- eq(str(td(days=999999999, hours=23, minutes=59, seconds=59,\r
- microseconds=999999)),\r
- "999999999 days, 23:59:59.999999")\r
-\r
- def test_roundtrip(self):\r
- for td in (timedelta(days=999999999, hours=23, minutes=59,\r
- seconds=59, microseconds=999999),\r
- timedelta(days=-999999999),\r
- timedelta(days=1, seconds=2, microseconds=3)):\r
-\r
- # Verify td -> string -> td identity.\r
- s = repr(td)\r
- self.assertTrue(s.startswith('datetime.'))\r
- s = s[9:]\r
- td2 = eval(s)\r
- self.assertEqual(td, td2)\r
-\r
- # Verify identity via reconstructing from pieces.\r
- td2 = timedelta(td.days, td.seconds, td.microseconds)\r
- self.assertEqual(td, td2)\r
-\r
- def test_resolution_info(self):\r
- self.assertIsInstance(timedelta.min, timedelta)\r
- self.assertIsInstance(timedelta.max, timedelta)\r
- self.assertIsInstance(timedelta.resolution, timedelta)\r
- self.assertTrue(timedelta.max > timedelta.min)\r
- self.assertEqual(timedelta.min, timedelta(-999999999))\r
- self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))\r
- self.assertEqual(timedelta.resolution, timedelta(0, 0, 1))\r
-\r
- def test_overflow(self):\r
- tiny = timedelta.resolution\r
-\r
- td = timedelta.min + tiny\r
- td -= tiny # no problem\r
- self.assertRaises(OverflowError, td.__sub__, tiny)\r
- self.assertRaises(OverflowError, td.__add__, -tiny)\r
-\r
- td = timedelta.max - tiny\r
- td += tiny # no problem\r
- self.assertRaises(OverflowError, td.__add__, tiny)\r
- self.assertRaises(OverflowError, td.__sub__, -tiny)\r
-\r
- self.assertRaises(OverflowError, lambda: -timedelta.max)\r
-\r
- def test_microsecond_rounding(self):\r
- td = timedelta\r
- eq = self.assertEqual\r
-\r
- # Single-field rounding.\r
- eq(td(milliseconds=0.4/1000), td(0)) # rounds to 0\r
- eq(td(milliseconds=-0.4/1000), td(0)) # rounds to 0\r
- eq(td(milliseconds=0.6/1000), td(microseconds=1))\r
- eq(td(milliseconds=-0.6/1000), td(microseconds=-1))\r
-\r
- # Rounding due to contributions from more than one field.\r
- us_per_hour = 3600e6\r
- us_per_day = us_per_hour * 24\r
- eq(td(days=.4/us_per_day), td(0))\r
- eq(td(hours=.2/us_per_hour), td(0))\r
- eq(td(days=.4/us_per_day, hours=.2/us_per_hour), td(microseconds=1))\r
-\r
- eq(td(days=-.4/us_per_day), td(0))\r
- eq(td(hours=-.2/us_per_hour), td(0))\r
- eq(td(days=-.4/us_per_day, hours=-.2/us_per_hour), td(microseconds=-1))\r
-\r
- def test_massive_normalization(self):\r
- td = timedelta(microseconds=-1)\r
- self.assertEqual((td.days, td.seconds, td.microseconds),\r
- (-1, 24*3600-1, 999999))\r
-\r
- def test_bool(self):\r
- self.assertTrue(timedelta(1))\r
- self.assertTrue(timedelta(0, 1))\r
- self.assertTrue(timedelta(0, 0, 1))\r
- self.assertTrue(timedelta(microseconds=1))\r
- self.assertTrue(not timedelta(0))\r
-\r
- def test_subclass_timedelta(self):\r
-\r
- class T(timedelta):\r
- @staticmethod\r
- def from_td(td):\r
- return T(td.days, td.seconds, td.microseconds)\r
-\r
- def as_hours(self):\r
- sum = (self.days * 24 +\r
- self.seconds / 3600.0 +\r
- self.microseconds / 3600e6)\r
- return round(sum)\r
-\r
- t1 = T(days=1)\r
- self.assertTrue(type(t1) is T)\r
- self.assertEqual(t1.as_hours(), 24)\r
-\r
- t2 = T(days=-1, seconds=-3600)\r
- self.assertTrue(type(t2) is T)\r
- self.assertEqual(t2.as_hours(), -25)\r
-\r
- t3 = t1 + t2\r
- self.assertTrue(type(t3) is timedelta)\r
- t4 = T.from_td(t3)\r
- self.assertTrue(type(t4) is T)\r
- self.assertEqual(t3.days, t4.days)\r
- self.assertEqual(t3.seconds, t4.seconds)\r
- self.assertEqual(t3.microseconds, t4.microseconds)\r
- self.assertEqual(str(t3), str(t4))\r
- self.assertEqual(t4.as_hours(), -1)\r
-\r
-#############################################################################\r
-# date tests\r
-\r
-class TestDateOnly(unittest.TestCase):\r
- # Tests here won't pass if also run on datetime objects, so don't\r
- # subclass this to test datetimes too.\r
-\r
- def test_delta_non_days_ignored(self):\r
- dt = date(2000, 1, 2)\r
- delta = timedelta(days=1, hours=2, minutes=3, seconds=4,\r
- microseconds=5)\r
- days = timedelta(delta.days)\r
- self.assertEqual(days, timedelta(1))\r
-\r
- dt2 = dt + delta\r
- self.assertEqual(dt2, dt + days)\r
-\r
- dt2 = delta + dt\r
- self.assertEqual(dt2, dt + days)\r
-\r
- dt2 = dt - delta\r
- self.assertEqual(dt2, dt - days)\r
-\r
- delta = -delta\r
- days = timedelta(delta.days)\r
- self.assertEqual(days, timedelta(-2))\r
-\r
- dt2 = dt + delta\r
- self.assertEqual(dt2, dt + days)\r
-\r
- dt2 = delta + dt\r
- self.assertEqual(dt2, dt + days)\r
-\r
- dt2 = dt - delta\r
- self.assertEqual(dt2, dt - days)\r
-\r
-class SubclassDate(date):\r
- sub_var = 1\r
-\r
-class TestDate(HarmlessMixedComparison, unittest.TestCase):\r
- # Tests here should pass for both dates and datetimes, except for a\r
- # few tests that TestDateTime overrides.\r
-\r
- theclass = date\r
-\r
- def test_basic_attributes(self):\r
- dt = self.theclass(2002, 3, 1)\r
- self.assertEqual(dt.year, 2002)\r
- self.assertEqual(dt.month, 3)\r
- self.assertEqual(dt.day, 1)\r
-\r
- def test_roundtrip(self):\r
- for dt in (self.theclass(1, 2, 3),\r
- self.theclass.today()):\r
- # Verify dt -> string -> date identity.\r
- s = repr(dt)\r
- self.assertTrue(s.startswith('datetime.'))\r
- s = s[9:]\r
- dt2 = eval(s)\r
- self.assertEqual(dt, dt2)\r
-\r
- # Verify identity via reconstructing from pieces.\r
- dt2 = self.theclass(dt.year, dt.month, dt.day)\r
- self.assertEqual(dt, dt2)\r
-\r
- def test_ordinal_conversions(self):\r
- # Check some fixed values.\r
- for y, m, d, n in [(1, 1, 1, 1), # calendar origin\r
- (1, 12, 31, 365),\r
- (2, 1, 1, 366),\r
- # first example from "Calendrical Calculations"\r
- (1945, 11, 12, 710347)]:\r
- d = self.theclass(y, m, d)\r
- self.assertEqual(n, d.toordinal())\r
- fromord = self.theclass.fromordinal(n)\r
- self.assertEqual(d, fromord)\r
- if hasattr(fromord, "hour"):\r
- # if we're checking something fancier than a date, verify\r
- # the extra fields have been zeroed out\r
- self.assertEqual(fromord.hour, 0)\r
- self.assertEqual(fromord.minute, 0)\r
- self.assertEqual(fromord.second, 0)\r
- self.assertEqual(fromord.microsecond, 0)\r
-\r
- # Check first and last days of year spottily across the whole\r
- # range of years supported.\r
- for year in xrange(MINYEAR, MAXYEAR+1, 7):\r
- # Verify (year, 1, 1) -> ordinal -> y, m, d is identity.\r
- d = self.theclass(year, 1, 1)\r
- n = d.toordinal()\r
- d2 = self.theclass.fromordinal(n)\r
- self.assertEqual(d, d2)\r
- # Verify that moving back a day gets to the end of year-1.\r
- if year > 1:\r
- d = self.theclass.fromordinal(n-1)\r
- d2 = self.theclass(year-1, 12, 31)\r
- self.assertEqual(d, d2)\r
- self.assertEqual(d2.toordinal(), n-1)\r
-\r
- # Test every day in a leap-year and a non-leap year.\r
- dim = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\r
- for year, isleap in (2000, True), (2002, False):\r
- n = self.theclass(year, 1, 1).toordinal()\r
- for month, maxday in zip(range(1, 13), dim):\r
- if month == 2 and isleap:\r
- maxday += 1\r
- for day in range(1, maxday+1):\r
- d = self.theclass(year, month, day)\r
- self.assertEqual(d.toordinal(), n)\r
- self.assertEqual(d, self.theclass.fromordinal(n))\r
- n += 1\r
-\r
- def test_extreme_ordinals(self):\r
- a = self.theclass.min\r
- a = self.theclass(a.year, a.month, a.day) # get rid of time parts\r
- aord = a.toordinal()\r
- b = a.fromordinal(aord)\r
- self.assertEqual(a, b)\r
-\r
- self.assertRaises(ValueError, lambda: a.fromordinal(aord - 1))\r
-\r
- b = a + timedelta(days=1)\r
- self.assertEqual(b.toordinal(), aord + 1)\r
- self.assertEqual(b, self.theclass.fromordinal(aord + 1))\r
-\r
- a = self.theclass.max\r
- a = self.theclass(a.year, a.month, a.day) # get rid of time parts\r
- aord = a.toordinal()\r
- b = a.fromordinal(aord)\r
- self.assertEqual(a, b)\r
-\r
- self.assertRaises(ValueError, lambda: a.fromordinal(aord + 1))\r
-\r
- b = a - timedelta(days=1)\r
- self.assertEqual(b.toordinal(), aord - 1)\r
- self.assertEqual(b, self.theclass.fromordinal(aord - 1))\r
-\r
- def test_bad_constructor_arguments(self):\r
- # bad years\r
- self.theclass(MINYEAR, 1, 1) # no exception\r
- self.theclass(MAXYEAR, 1, 1) # no exception\r
- self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)\r
- self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)\r
- # bad months\r
- self.theclass(2000, 1, 1) # no exception\r
- self.theclass(2000, 12, 1) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 0, 1)\r
- self.assertRaises(ValueError, self.theclass, 2000, 13, 1)\r
- # bad days\r
- self.theclass(2000, 2, 29) # no exception\r
- self.theclass(2004, 2, 29) # no exception\r
- self.theclass(2400, 2, 29) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 2, 30)\r
- self.assertRaises(ValueError, self.theclass, 2001, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 2100, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 1900, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 0)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 32)\r
-\r
- def test_hash_equality(self):\r
- d = self.theclass(2000, 12, 31)\r
- # same thing\r
- e = self.theclass(2000, 12, 31)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- d = self.theclass(2001, 1, 1)\r
- # same thing\r
- e = self.theclass(2001, 1, 1)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- def test_computations(self):\r
- a = self.theclass(2002, 1, 31)\r
- b = self.theclass(1956, 1, 31)\r
-\r
- diff = a-b\r
- self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))\r
- self.assertEqual(diff.seconds, 0)\r
- self.assertEqual(diff.microseconds, 0)\r
-\r
- day = timedelta(1)\r
- week = timedelta(7)\r
- a = self.theclass(2002, 3, 2)\r
- self.assertEqual(a + day, self.theclass(2002, 3, 3))\r
- self.assertEqual(day + a, self.theclass(2002, 3, 3))\r
- self.assertEqual(a - day, self.theclass(2002, 3, 1))\r
- self.assertEqual(-day + a, self.theclass(2002, 3, 1))\r
- self.assertEqual(a + week, self.theclass(2002, 3, 9))\r
- self.assertEqual(a - week, self.theclass(2002, 2, 23))\r
- self.assertEqual(a + 52*week, self.theclass(2003, 3, 1))\r
- self.assertEqual(a - 52*week, self.theclass(2001, 3, 3))\r
- self.assertEqual((a + week) - a, week)\r
- self.assertEqual((a + day) - a, day)\r
- self.assertEqual((a - week) - a, -week)\r
- self.assertEqual((a - day) - a, -day)\r
- self.assertEqual(a - (a + week), -week)\r
- self.assertEqual(a - (a + day), -day)\r
- self.assertEqual(a - (a - week), week)\r
- self.assertEqual(a - (a - day), day)\r
-\r
- # Add/sub ints, longs, floats should be illegal\r
- for i in 1, 1L, 1.0:\r
- self.assertRaises(TypeError, lambda: a+i)\r
- self.assertRaises(TypeError, lambda: a-i)\r
- self.assertRaises(TypeError, lambda: i+a)\r
- self.assertRaises(TypeError, lambda: i-a)\r
-\r
- # delta - date is senseless.\r
- self.assertRaises(TypeError, lambda: day - a)\r
- # mixing date and (delta or date) via * or // is senseless\r
- self.assertRaises(TypeError, lambda: day * a)\r
- self.assertRaises(TypeError, lambda: a * day)\r
- self.assertRaises(TypeError, lambda: day // a)\r
- self.assertRaises(TypeError, lambda: a // day)\r
- self.assertRaises(TypeError, lambda: a * a)\r
- self.assertRaises(TypeError, lambda: a // a)\r
- # date + date is senseless\r
- self.assertRaises(TypeError, lambda: a + a)\r
-\r
- def test_overflow(self):\r
- tiny = self.theclass.resolution\r
-\r
- for delta in [tiny, timedelta(1), timedelta(2)]:\r
- dt = self.theclass.min + delta\r
- dt -= delta # no problem\r
- self.assertRaises(OverflowError, dt.__sub__, delta)\r
- self.assertRaises(OverflowError, dt.__add__, -delta)\r
-\r
- dt = self.theclass.max - delta\r
- dt += delta # no problem\r
- self.assertRaises(OverflowError, dt.__add__, delta)\r
- self.assertRaises(OverflowError, dt.__sub__, -delta)\r
-\r
- def test_fromtimestamp(self):\r
- import time\r
-\r
- # Try an arbitrary fixed value.\r
- year, month, day = 1999, 9, 19\r
- ts = time.mktime((year, month, day, 0, 0, 0, 0, 0, -1))\r
- d = self.theclass.fromtimestamp(ts)\r
- self.assertEqual(d.year, year)\r
- self.assertEqual(d.month, month)\r
- self.assertEqual(d.day, day)\r
-\r
- def test_insane_fromtimestamp(self):\r
- # It's possible that some platform maps time_t to double,\r
- # and that this test will fail there. This test should\r
- # exempt such platforms (provided they return reasonable\r
- # results!).\r
- for insane in -1e200, 1e200:\r
- self.assertRaises(ValueError, self.theclass.fromtimestamp,\r
- insane)\r
-\r
- def test_today(self):\r
- import time\r
-\r
- # We claim that today() is like fromtimestamp(time.time()), so\r
- # prove it.\r
- for dummy in range(3):\r
- today = self.theclass.today()\r
- ts = time.time()\r
- todayagain = self.theclass.fromtimestamp(ts)\r
- if today == todayagain:\r
- break\r
- # There are several legit reasons that could fail:\r
- # 1. It recently became midnight, between the today() and the\r
- # time() calls.\r
- # 2. The platform time() has such fine resolution that we'll\r
- # never get the same value twice.\r
- # 3. The platform time() has poor resolution, and we just\r
- # happened to call today() right before a resolution quantum\r
- # boundary.\r
- # 4. The system clock got fiddled between calls.\r
- # In any case, wait a little while and try again.\r
- time.sleep(0.1)\r
-\r
- # It worked or it didn't. If it didn't, assume it's reason #2, and\r
- # let the test pass if they're within half a second of each other.\r
- self.assertTrue(today == todayagain or\r
- abs(todayagain - today) < timedelta(seconds=0.5))\r
-\r
- def test_weekday(self):\r
- for i in range(7):\r
- # March 4, 2002 is a Monday\r
- self.assertEqual(self.theclass(2002, 3, 4+i).weekday(), i)\r
- self.assertEqual(self.theclass(2002, 3, 4+i).isoweekday(), i+1)\r
- # January 2, 1956 is a Monday\r
- self.assertEqual(self.theclass(1956, 1, 2+i).weekday(), i)\r
- self.assertEqual(self.theclass(1956, 1, 2+i).isoweekday(), i+1)\r
-\r
- def test_isocalendar(self):\r
- # Check examples from\r
- # http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm\r
- for i in range(7):\r
- d = self.theclass(2003, 12, 22+i)\r
- self.assertEqual(d.isocalendar(), (2003, 52, i+1))\r
- d = self.theclass(2003, 12, 29) + timedelta(i)\r
- self.assertEqual(d.isocalendar(), (2004, 1, i+1))\r
- d = self.theclass(2004, 1, 5+i)\r
- self.assertEqual(d.isocalendar(), (2004, 2, i+1))\r
- d = self.theclass(2009, 12, 21+i)\r
- self.assertEqual(d.isocalendar(), (2009, 52, i+1))\r
- d = self.theclass(2009, 12, 28) + timedelta(i)\r
- self.assertEqual(d.isocalendar(), (2009, 53, i+1))\r
- d = self.theclass(2010, 1, 4+i)\r
- self.assertEqual(d.isocalendar(), (2010, 1, i+1))\r
-\r
- def test_iso_long_years(self):\r
- # Calculate long ISO years and compare to table from\r
- # http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm\r
- ISO_LONG_YEARS_TABLE = """\r
- 4 32 60 88\r
- 9 37 65 93\r
- 15 43 71 99\r
- 20 48 76\r
- 26 54 82\r
-\r
- 105 133 161 189\r
- 111 139 167 195\r
- 116 144 172\r
- 122 150 178\r
- 128 156 184\r
-\r
- 201 229 257 285\r
- 207 235 263 291\r
- 212 240 268 296\r
- 218 246 274\r
- 224 252 280\r
-\r
- 303 331 359 387\r
- 308 336 364 392\r
- 314 342 370 398\r
- 320 348 376\r
- 325 353 381\r
- """\r
- iso_long_years = map(int, ISO_LONG_YEARS_TABLE.split())\r
- iso_long_years.sort()\r
- L = []\r
- for i in range(400):\r
- d = self.theclass(2000+i, 12, 31)\r
- d1 = self.theclass(1600+i, 12, 31)\r
- self.assertEqual(d.isocalendar()[1:], d1.isocalendar()[1:])\r
- if d.isocalendar()[1] == 53:\r
- L.append(i)\r
- self.assertEqual(L, iso_long_years)\r
-\r
- def test_isoformat(self):\r
- t = self.theclass(2, 3, 2)\r
- self.assertEqual(t.isoformat(), "0002-03-02")\r
-\r
- def test_ctime(self):\r
- t = self.theclass(2002, 3, 2)\r
- self.assertEqual(t.ctime(), "Sat Mar 2 00:00:00 2002")\r
-\r
- def test_strftime(self):\r
- t = self.theclass(2005, 3, 2)\r
- self.assertEqual(t.strftime("m:%m d:%d y:%y"), "m:03 d:02 y:05")\r
- self.assertEqual(t.strftime(""), "") # SF bug #761337\r
- self.assertEqual(t.strftime('x'*1000), 'x'*1000) # SF bug #1556784\r
-\r
- self.assertRaises(TypeError, t.strftime) # needs an arg\r
- self.assertRaises(TypeError, t.strftime, "one", "two") # too many args\r
- self.assertRaises(TypeError, t.strftime, 42) # arg wrong type\r
-\r
- # test that unicode input is allowed (issue 2782)\r
- self.assertEqual(t.strftime(u"%m"), "03")\r
-\r
- # A naive object replaces %z and %Z w/ empty strings.\r
- self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")\r
-\r
- #make sure that invalid format specifiers are handled correctly\r
- #self.assertRaises(ValueError, t.strftime, "%e")\r
- #self.assertRaises(ValueError, t.strftime, "%")\r
- #self.assertRaises(ValueError, t.strftime, "%#")\r
-\r
- #oh well, some systems just ignore those invalid ones.\r
- #at least, excercise them to make sure that no crashes\r
- #are generated\r
- for f in ["%e", "%", "%#"]:\r
- try:\r
- t.strftime(f)\r
- except ValueError:\r
- pass\r
-\r
- #check that this standard extension works\r
- t.strftime("%f")\r
-\r
-\r
- def test_format(self):\r
- dt = self.theclass(2007, 9, 10)\r
- self.assertEqual(dt.__format__(''), str(dt))\r
-\r
- # check that a derived class's __str__() gets called\r
- class A(self.theclass):\r
- def __str__(self):\r
- return 'A'\r
- a = A(2007, 9, 10)\r
- self.assertEqual(a.__format__(''), 'A')\r
-\r
- # check that a derived class's strftime gets called\r
- class B(self.theclass):\r
- def strftime(self, format_spec):\r
- return 'B'\r
- b = B(2007, 9, 10)\r
- self.assertEqual(b.__format__(''), str(dt))\r
-\r
- for fmt in ["m:%m d:%d y:%y",\r
- "m:%m d:%d y:%y H:%H M:%M S:%S",\r
- "%z %Z",\r
- ]:\r
- self.assertEqual(dt.__format__(fmt), dt.strftime(fmt))\r
- self.assertEqual(a.__format__(fmt), dt.strftime(fmt))\r
- self.assertEqual(b.__format__(fmt), 'B')\r
-\r
- def test_resolution_info(self):\r
- self.assertIsInstance(self.theclass.min, self.theclass)\r
- self.assertIsInstance(self.theclass.max, self.theclass)\r
- self.assertIsInstance(self.theclass.resolution, timedelta)\r
- self.assertTrue(self.theclass.max > self.theclass.min)\r
-\r
- def test_extreme_timedelta(self):\r
- big = self.theclass.max - self.theclass.min\r
- # 3652058 days, 23 hours, 59 minutes, 59 seconds, 999999 microseconds\r
- n = (big.days*24*3600 + big.seconds)*1000000 + big.microseconds\r
- # n == 315537897599999999 ~= 2**58.13\r
- justasbig = timedelta(0, 0, n)\r
- self.assertEqual(big, justasbig)\r
- self.assertEqual(self.theclass.min + big, self.theclass.max)\r
- self.assertEqual(self.theclass.max - big, self.theclass.min)\r
-\r
- def test_timetuple(self):\r
- for i in range(7):\r
- # January 2, 1956 is a Monday (0)\r
- d = self.theclass(1956, 1, 2+i)\r
- t = d.timetuple()\r
- self.assertEqual(t, (1956, 1, 2+i, 0, 0, 0, i, 2+i, -1))\r
- # February 1, 1956 is a Wednesday (2)\r
- d = self.theclass(1956, 2, 1+i)\r
- t = d.timetuple()\r
- self.assertEqual(t, (1956, 2, 1+i, 0, 0, 0, (2+i)%7, 32+i, -1))\r
- # March 1, 1956 is a Thursday (3), and is the 31+29+1 = 61st day\r
- # of the year.\r
- d = self.theclass(1956, 3, 1+i)\r
- t = d.timetuple()\r
- self.assertEqual(t, (1956, 3, 1+i, 0, 0, 0, (3+i)%7, 61+i, -1))\r
- self.assertEqual(t.tm_year, 1956)\r
- self.assertEqual(t.tm_mon, 3)\r
- self.assertEqual(t.tm_mday, 1+i)\r
- self.assertEqual(t.tm_hour, 0)\r
- self.assertEqual(t.tm_min, 0)\r
- self.assertEqual(t.tm_sec, 0)\r
- self.assertEqual(t.tm_wday, (3+i)%7)\r
- self.assertEqual(t.tm_yday, 61+i)\r
- self.assertEqual(t.tm_isdst, -1)\r
-\r
- def test_pickling(self):\r
- args = 6, 7, 23\r
- orig = self.theclass(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_compare(self):\r
- t1 = self.theclass(2, 3, 4)\r
- t2 = self.theclass(2, 3, 4)\r
- self.assertTrue(t1 == t2)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t1 >= t2)\r
- self.assertTrue(not t1 != t2)\r
- self.assertTrue(not t1 < t2)\r
- self.assertTrue(not t1 > t2)\r
- self.assertEqual(cmp(t1, t2), 0)\r
- self.assertEqual(cmp(t2, t1), 0)\r
-\r
- for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):\r
- t2 = self.theclass(*args) # this is larger than t1\r
- self.assertTrue(t1 < t2)\r
- self.assertTrue(t2 > t1)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t2 >= t1)\r
- self.assertTrue(t1 != t2)\r
- self.assertTrue(t2 != t1)\r
- self.assertTrue(not t1 == t2)\r
- self.assertTrue(not t2 == t1)\r
- self.assertTrue(not t1 > t2)\r
- self.assertTrue(not t2 < t1)\r
- self.assertTrue(not t1 >= t2)\r
- self.assertTrue(not t2 <= t1)\r
- self.assertEqual(cmp(t1, t2), -1)\r
- self.assertEqual(cmp(t2, t1), 1)\r
-\r
- for badarg in OTHERSTUFF:\r
- self.assertEqual(t1 == badarg, False)\r
- self.assertEqual(t1 != badarg, True)\r
- self.assertEqual(badarg == t1, False)\r
- self.assertEqual(badarg != t1, True)\r
-\r
- self.assertRaises(TypeError, lambda: t1 < badarg)\r
- self.assertRaises(TypeError, lambda: t1 > badarg)\r
- self.assertRaises(TypeError, lambda: t1 >= badarg)\r
- self.assertRaises(TypeError, lambda: badarg <= t1)\r
- self.assertRaises(TypeError, lambda: badarg < t1)\r
- self.assertRaises(TypeError, lambda: badarg > t1)\r
- self.assertRaises(TypeError, lambda: badarg >= t1)\r
-\r
- def test_mixed_compare(self):\r
- our = self.theclass(2000, 4, 5)\r
- self.assertRaises(TypeError, cmp, our, 1)\r
- self.assertRaises(TypeError, cmp, 1, our)\r
-\r
- class AnotherDateTimeClass(object):\r
- def __cmp__(self, other):\r
- # Return "equal" so calling this can't be confused with\r
- # compare-by-address (which never says "equal" for distinct\r
- # objects).\r
- return 0\r
- __hash__ = None # Silence Py3k warning\r
-\r
- # This still errors, because date and datetime comparison raise\r
- # TypeError instead of NotImplemented when they don't know what to\r
- # do, in order to stop comparison from falling back to the default\r
- # compare-by-address.\r
- their = AnotherDateTimeClass()\r
- self.assertRaises(TypeError, cmp, our, their)\r
- # Oops: The next stab raises TypeError in the C implementation,\r
- # but not in the Python implementation of datetime. The difference\r
- # is due to that the Python implementation defines __cmp__ but\r
- # the C implementation defines tp_richcompare. This is more pain\r
- # to fix than it's worth, so commenting out the test.\r
- # self.assertEqual(cmp(their, our), 0)\r
-\r
- # But date and datetime comparison return NotImplemented instead if the\r
- # other object has a timetuple attr. This gives the other object a\r
- # chance to do the comparison.\r
- class Comparable(AnotherDateTimeClass):\r
- def timetuple(self):\r
- return ()\r
-\r
- their = Comparable()\r
- self.assertEqual(cmp(our, their), 0)\r
- self.assertEqual(cmp(their, our), 0)\r
- self.assertTrue(our == their)\r
- self.assertTrue(their == our)\r
-\r
- def test_bool(self):\r
- # All dates are considered true.\r
- self.assertTrue(self.theclass.min)\r
- self.assertTrue(self.theclass.max)\r
-\r
- def test_strftime_out_of_range(self):\r
- # For nasty technical reasons, we can't handle years before 1900.\r
- cls = self.theclass\r
- self.assertEqual(cls(1900, 1, 1).strftime("%Y"), "1900")\r
- for y in 1, 49, 51, 99, 100, 1000, 1899:\r
- self.assertRaises(ValueError, cls(y, 1, 1).strftime, "%Y")\r
-\r
- def test_replace(self):\r
- cls = self.theclass\r
- args = [1, 2, 3]\r
- base = cls(*args)\r
- self.assertEqual(base, base.replace())\r
-\r
- i = 0\r
- for name, newval in (("year", 2),\r
- ("month", 3),\r
- ("day", 4)):\r
- newargs = args[:]\r
- newargs[i] = newval\r
- expected = cls(*newargs)\r
- got = base.replace(**{name: newval})\r
- self.assertEqual(expected, got)\r
- i += 1\r
-\r
- # Out of bounds.\r
- base = cls(2000, 2, 29)\r
- self.assertRaises(ValueError, base.replace, year=2001)\r
-\r
- def test_subclass_date(self):\r
-\r
- class C(self.theclass):\r
- theAnswer = 42\r
-\r
- def __new__(cls, *args, **kws):\r
- temp = kws.copy()\r
- extra = temp.pop('extra')\r
- result = self.theclass.__new__(cls, *args, **temp)\r
- result.extra = extra\r
- return result\r
-\r
- def newmeth(self, start):\r
- return start + self.year + self.month\r
-\r
- args = 2003, 4, 14\r
-\r
- dt1 = self.theclass(*args)\r
- dt2 = C(*args, **{'extra': 7})\r
-\r
- self.assertEqual(dt2.__class__, C)\r
- self.assertEqual(dt2.theAnswer, 42)\r
- self.assertEqual(dt2.extra, 7)\r
- self.assertEqual(dt1.toordinal(), dt2.toordinal())\r
- self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month - 7)\r
-\r
- def test_pickling_subclass_date(self):\r
-\r
- args = 6, 7, 23\r
- orig = SubclassDate(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_backdoor_resistance(self):\r
- # For fast unpickling, the constructor accepts a pickle string.\r
- # This is a low-overhead backdoor. A user can (by intent or\r
- # mistake) pass a string directly, which (if it's the right length)\r
- # will get treated like a pickle, and bypass the normal sanity\r
- # checks in the constructor. This can create insane objects.\r
- # The constructor doesn't want to burn the time to validate all\r
- # fields, but does check the month field. This stops, e.g.,\r
- # datetime.datetime('1995-03-25') from yielding an insane object.\r
- base = '1995-03-25'\r
- if not issubclass(self.theclass, datetime):\r
- base = base[:4]\r
- for month_byte in '9', chr(0), chr(13), '\xff':\r
- self.assertRaises(TypeError, self.theclass,\r
- base[:2] + month_byte + base[3:])\r
- for ord_byte in range(1, 13):\r
- # This shouldn't blow up because of the month byte alone. If\r
- # the implementation changes to do more-careful checking, it may\r
- # blow up because other fields are insane.\r
- self.theclass(base[:2] + chr(ord_byte) + base[3:])\r
-\r
-#############################################################################\r
-# datetime tests\r
-\r
-class SubclassDatetime(datetime):\r
- sub_var = 1\r
-\r
-class TestDateTime(TestDate):\r
-\r
- theclass = datetime\r
-\r
- def test_basic_attributes(self):\r
- dt = self.theclass(2002, 3, 1, 12, 0)\r
- self.assertEqual(dt.year, 2002)\r
- self.assertEqual(dt.month, 3)\r
- self.assertEqual(dt.day, 1)\r
- self.assertEqual(dt.hour, 12)\r
- self.assertEqual(dt.minute, 0)\r
- self.assertEqual(dt.second, 0)\r
- self.assertEqual(dt.microsecond, 0)\r
-\r
- def test_basic_attributes_nonzero(self):\r
- # Make sure all attributes are non-zero so bugs in\r
- # bit-shifting access show up.\r
- dt = self.theclass(2002, 3, 1, 12, 59, 59, 8000)\r
- self.assertEqual(dt.year, 2002)\r
- self.assertEqual(dt.month, 3)\r
- self.assertEqual(dt.day, 1)\r
- self.assertEqual(dt.hour, 12)\r
- self.assertEqual(dt.minute, 59)\r
- self.assertEqual(dt.second, 59)\r
- self.assertEqual(dt.microsecond, 8000)\r
-\r
- def test_roundtrip(self):\r
- for dt in (self.theclass(1, 2, 3, 4, 5, 6, 7),\r
- self.theclass.now()):\r
- # Verify dt -> string -> datetime identity.\r
- s = repr(dt)\r
- self.assertTrue(s.startswith('datetime.'))\r
- s = s[9:]\r
- dt2 = eval(s)\r
- self.assertEqual(dt, dt2)\r
-\r
- # Verify identity via reconstructing from pieces.\r
- dt2 = self.theclass(dt.year, dt.month, dt.day,\r
- dt.hour, dt.minute, dt.second,\r
- dt.microsecond)\r
- self.assertEqual(dt, dt2)\r
-\r
- def test_isoformat(self):\r
- t = self.theclass(2, 3, 2, 4, 5, 1, 123)\r
- self.assertEqual(t.isoformat(), "0002-03-02T04:05:01.000123")\r
- self.assertEqual(t.isoformat('T'), "0002-03-02T04:05:01.000123")\r
- self.assertEqual(t.isoformat(' '), "0002-03-02 04:05:01.000123")\r
- self.assertEqual(t.isoformat('\x00'), "0002-03-02\x0004:05:01.000123")\r
- # str is ISO format with the separator forced to a blank.\r
- self.assertEqual(str(t), "0002-03-02 04:05:01.000123")\r
-\r
- t = self.theclass(2, 3, 2)\r
- self.assertEqual(t.isoformat(), "0002-03-02T00:00:00")\r
- self.assertEqual(t.isoformat('T'), "0002-03-02T00:00:00")\r
- self.assertEqual(t.isoformat(' '), "0002-03-02 00:00:00")\r
- # str is ISO format with the separator forced to a blank.\r
- self.assertEqual(str(t), "0002-03-02 00:00:00")\r
-\r
- def test_format(self):\r
- dt = self.theclass(2007, 9, 10, 4, 5, 1, 123)\r
- self.assertEqual(dt.__format__(''), str(dt))\r
-\r
- # check that a derived class's __str__() gets called\r
- class A(self.theclass):\r
- def __str__(self):\r
- return 'A'\r
- a = A(2007, 9, 10, 4, 5, 1, 123)\r
- self.assertEqual(a.__format__(''), 'A')\r
-\r
- # check that a derived class's strftime gets called\r
- class B(self.theclass):\r
- def strftime(self, format_spec):\r
- return 'B'\r
- b = B(2007, 9, 10, 4, 5, 1, 123)\r
- self.assertEqual(b.__format__(''), str(dt))\r
-\r
- for fmt in ["m:%m d:%d y:%y",\r
- "m:%m d:%d y:%y H:%H M:%M S:%S",\r
- "%z %Z",\r
- ]:\r
- self.assertEqual(dt.__format__(fmt), dt.strftime(fmt))\r
- self.assertEqual(a.__format__(fmt), dt.strftime(fmt))\r
- self.assertEqual(b.__format__(fmt), 'B')\r
-\r
- def test_more_ctime(self):\r
- # Test fields that TestDate doesn't touch.\r
- import time\r
-\r
- t = self.theclass(2002, 3, 2, 18, 3, 5, 123)\r
- self.assertEqual(t.ctime(), "Sat Mar 2 18:03:05 2002")\r
- # Oops! The next line fails on Win2K under MSVC 6, so it's commented\r
- # out. The difference is that t.ctime() produces " 2" for the day,\r
- # but platform ctime() produces "02" for the day. According to\r
- # C99, t.ctime() is correct here.\r
- # self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))\r
-\r
- # So test a case where that difference doesn't matter.\r
- t = self.theclass(2002, 3, 22, 18, 3, 5, 123)\r
- self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))\r
-\r
- def test_tz_independent_comparing(self):\r
- dt1 = self.theclass(2002, 3, 1, 9, 0, 0)\r
- dt2 = self.theclass(2002, 3, 1, 10, 0, 0)\r
- dt3 = self.theclass(2002, 3, 1, 9, 0, 0)\r
- self.assertEqual(dt1, dt3)\r
- self.assertTrue(dt2 > dt3)\r
-\r
- # Make sure comparison doesn't forget microseconds, and isn't done\r
- # via comparing a float timestamp (an IEEE double doesn't have enough\r
- # precision to span microsecond resolution across years 1 thru 9999,\r
- # so comparing via timestamp necessarily calls some distinct values\r
- # equal).\r
- dt1 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999998)\r
- us = timedelta(microseconds=1)\r
- dt2 = dt1 + us\r
- self.assertEqual(dt2 - dt1, us)\r
- self.assertTrue(dt1 < dt2)\r
-\r
- def test_strftime_with_bad_tzname_replace(self):\r
- # verify ok if tzinfo.tzname().replace() returns a non-string\r
- class MyTzInfo(FixedOffset):\r
- def tzname(self, dt):\r
- class MyStr(str):\r
- def replace(self, *args):\r
- return None\r
- return MyStr('name')\r
- t = self.theclass(2005, 3, 2, 0, 0, 0, 0, MyTzInfo(3, 'name'))\r
- self.assertRaises(TypeError, t.strftime, '%Z')\r
-\r
- def test_bad_constructor_arguments(self):\r
- # bad years\r
- self.theclass(MINYEAR, 1, 1) # no exception\r
- self.theclass(MAXYEAR, 1, 1) # no exception\r
- self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)\r
- self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)\r
- # bad months\r
- self.theclass(2000, 1, 1) # no exception\r
- self.theclass(2000, 12, 1) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 0, 1)\r
- self.assertRaises(ValueError, self.theclass, 2000, 13, 1)\r
- # bad days\r
- self.theclass(2000, 2, 29) # no exception\r
- self.theclass(2004, 2, 29) # no exception\r
- self.theclass(2400, 2, 29) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 2, 30)\r
- self.assertRaises(ValueError, self.theclass, 2001, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 2100, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 1900, 2, 29)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 0)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 32)\r
- # bad hours\r
- self.theclass(2000, 1, 31, 0) # no exception\r
- self.theclass(2000, 1, 31, 23) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, -1)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 24)\r
- # bad minutes\r
- self.theclass(2000, 1, 31, 23, 0) # no exception\r
- self.theclass(2000, 1, 31, 23, 59) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, -1)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 60)\r
- # bad seconds\r
- self.theclass(2000, 1, 31, 23, 59, 0) # no exception\r
- self.theclass(2000, 1, 31, 23, 59, 59) # no exception\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, -1)\r
- self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, 60)\r
- # bad microseconds\r
- self.theclass(2000, 1, 31, 23, 59, 59, 0) # no exception\r
- self.theclass(2000, 1, 31, 23, 59, 59, 999999) # no exception\r
- self.assertRaises(ValueError, self.theclass,\r
- 2000, 1, 31, 23, 59, 59, -1)\r
- self.assertRaises(ValueError, self.theclass,\r
- 2000, 1, 31, 23, 59, 59,\r
- 1000000)\r
-\r
- def test_hash_equality(self):\r
- d = self.theclass(2000, 12, 31, 23, 30, 17)\r
- e = self.theclass(2000, 12, 31, 23, 30, 17)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- d = self.theclass(2001, 1, 1, 0, 5, 17)\r
- e = self.theclass(2001, 1, 1, 0, 5, 17)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- def test_computations(self):\r
- a = self.theclass(2002, 1, 31)\r
- b = self.theclass(1956, 1, 31)\r
- diff = a-b\r
- self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))\r
- self.assertEqual(diff.seconds, 0)\r
- self.assertEqual(diff.microseconds, 0)\r
- a = self.theclass(2002, 3, 2, 17, 6)\r
- millisec = timedelta(0, 0, 1000)\r
- hour = timedelta(0, 3600)\r
- day = timedelta(1)\r
- week = timedelta(7)\r
- self.assertEqual(a + hour, self.theclass(2002, 3, 2, 18, 6))\r
- self.assertEqual(hour + a, self.theclass(2002, 3, 2, 18, 6))\r
- self.assertEqual(a + 10*hour, self.theclass(2002, 3, 3, 3, 6))\r
- self.assertEqual(a - hour, self.theclass(2002, 3, 2, 16, 6))\r
- self.assertEqual(-hour + a, self.theclass(2002, 3, 2, 16, 6))\r
- self.assertEqual(a - hour, a + -hour)\r
- self.assertEqual(a - 20*hour, self.theclass(2002, 3, 1, 21, 6))\r
- self.assertEqual(a + day, self.theclass(2002, 3, 3, 17, 6))\r
- self.assertEqual(a - day, self.theclass(2002, 3, 1, 17, 6))\r
- self.assertEqual(a + week, self.theclass(2002, 3, 9, 17, 6))\r
- self.assertEqual(a - week, self.theclass(2002, 2, 23, 17, 6))\r
- self.assertEqual(a + 52*week, self.theclass(2003, 3, 1, 17, 6))\r
- self.assertEqual(a - 52*week, self.theclass(2001, 3, 3, 17, 6))\r
- self.assertEqual((a + week) - a, week)\r
- self.assertEqual((a + day) - a, day)\r
- self.assertEqual((a + hour) - a, hour)\r
- self.assertEqual((a + millisec) - a, millisec)\r
- self.assertEqual((a - week) - a, -week)\r
- self.assertEqual((a - day) - a, -day)\r
- self.assertEqual((a - hour) - a, -hour)\r
- self.assertEqual((a - millisec) - a, -millisec)\r
- self.assertEqual(a - (a + week), -week)\r
- self.assertEqual(a - (a + day), -day)\r
- self.assertEqual(a - (a + hour), -hour)\r
- self.assertEqual(a - (a + millisec), -millisec)\r
- self.assertEqual(a - (a - week), week)\r
- self.assertEqual(a - (a - day), day)\r
- self.assertEqual(a - (a - hour), hour)\r
- self.assertEqual(a - (a - millisec), millisec)\r
- self.assertEqual(a + (week + day + hour + millisec),\r
- self.theclass(2002, 3, 10, 18, 6, 0, 1000))\r
- self.assertEqual(a + (week + day + hour + millisec),\r
- (((a + week) + day) + hour) + millisec)\r
- self.assertEqual(a - (week + day + hour + millisec),\r
- self.theclass(2002, 2, 22, 16, 5, 59, 999000))\r
- self.assertEqual(a - (week + day + hour + millisec),\r
- (((a - week) - day) - hour) - millisec)\r
- # Add/sub ints, longs, floats should be illegal\r
- for i in 1, 1L, 1.0:\r
- self.assertRaises(TypeError, lambda: a+i)\r
- self.assertRaises(TypeError, lambda: a-i)\r
- self.assertRaises(TypeError, lambda: i+a)\r
- self.assertRaises(TypeError, lambda: i-a)\r
-\r
- # delta - datetime is senseless.\r
- self.assertRaises(TypeError, lambda: day - a)\r
- # mixing datetime and (delta or datetime) via * or // is senseless\r
- self.assertRaises(TypeError, lambda: day * a)\r
- self.assertRaises(TypeError, lambda: a * day)\r
- self.assertRaises(TypeError, lambda: day // a)\r
- self.assertRaises(TypeError, lambda: a // day)\r
- self.assertRaises(TypeError, lambda: a * a)\r
- self.assertRaises(TypeError, lambda: a // a)\r
- # datetime + datetime is senseless\r
- self.assertRaises(TypeError, lambda: a + a)\r
-\r
- def test_pickling(self):\r
- args = 6, 7, 23, 20, 59, 1, 64**2\r
- orig = self.theclass(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_more_pickling(self):\r
- a = self.theclass(2003, 2, 7, 16, 48, 37, 444116)\r
- s = pickle.dumps(a)\r
- b = pickle.loads(s)\r
- self.assertEqual(b.year, 2003)\r
- self.assertEqual(b.month, 2)\r
- self.assertEqual(b.day, 7)\r
-\r
- def test_pickling_subclass_datetime(self):\r
- args = 6, 7, 23, 20, 59, 1, 64**2\r
- orig = SubclassDatetime(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_more_compare(self):\r
- # The test_compare() inherited from TestDate covers the error cases.\r
- # We just want to test lexicographic ordering on the members datetime\r
- # has that date lacks.\r
- args = [2000, 11, 29, 20, 58, 16, 999998]\r
- t1 = self.theclass(*args)\r
- t2 = self.theclass(*args)\r
- self.assertTrue(t1 == t2)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t1 >= t2)\r
- self.assertTrue(not t1 != t2)\r
- self.assertTrue(not t1 < t2)\r
- self.assertTrue(not t1 > t2)\r
- self.assertEqual(cmp(t1, t2), 0)\r
- self.assertEqual(cmp(t2, t1), 0)\r
-\r
- for i in range(len(args)):\r
- newargs = args[:]\r
- newargs[i] = args[i] + 1\r
- t2 = self.theclass(*newargs) # this is larger than t1\r
- self.assertTrue(t1 < t2)\r
- self.assertTrue(t2 > t1)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t2 >= t1)\r
- self.assertTrue(t1 != t2)\r
- self.assertTrue(t2 != t1)\r
- self.assertTrue(not t1 == t2)\r
- self.assertTrue(not t2 == t1)\r
- self.assertTrue(not t1 > t2)\r
- self.assertTrue(not t2 < t1)\r
- self.assertTrue(not t1 >= t2)\r
- self.assertTrue(not t2 <= t1)\r
- self.assertEqual(cmp(t1, t2), -1)\r
- self.assertEqual(cmp(t2, t1), 1)\r
-\r
-\r
- # A helper for timestamp constructor tests.\r
- def verify_field_equality(self, expected, got):\r
- self.assertEqual(expected.tm_year, got.year)\r
- self.assertEqual(expected.tm_mon, got.month)\r
- self.assertEqual(expected.tm_mday, got.day)\r
- self.assertEqual(expected.tm_hour, got.hour)\r
- self.assertEqual(expected.tm_min, got.minute)\r
- self.assertEqual(expected.tm_sec, got.second)\r
-\r
- def test_fromtimestamp(self):\r
- import time\r
-\r
- ts = time.time()\r
- expected = time.localtime(ts)\r
- got = self.theclass.fromtimestamp(ts)\r
- self.verify_field_equality(expected, got)\r
-\r
- def test_utcfromtimestamp(self):\r
- import time\r
-\r
- ts = time.time()\r
- expected = time.gmtime(ts)\r
- got = self.theclass.utcfromtimestamp(ts)\r
- self.verify_field_equality(expected, got)\r
-\r
- def test_microsecond_rounding(self):\r
- # Test whether fromtimestamp "rounds up" floats that are less\r
- # than one microsecond smaller than an integer.\r
- self.assertEqual(self.theclass.fromtimestamp(0.9999999),\r
- self.theclass.fromtimestamp(1))\r
-\r
- def test_insane_fromtimestamp(self):\r
- # It's possible that some platform maps time_t to double,\r
- # and that this test will fail there. This test should\r
- # exempt such platforms (provided they return reasonable\r
- # results!).\r
- for insane in -1e200, 1e200:\r
- self.assertRaises(ValueError, self.theclass.fromtimestamp,\r
- insane)\r
-\r
- def test_insane_utcfromtimestamp(self):\r
- # It's possible that some platform maps time_t to double,\r
- # and that this test will fail there. This test should\r
- # exempt such platforms (provided they return reasonable\r
- # results!).\r
- for insane in -1e200, 1e200:\r
- self.assertRaises(ValueError, self.theclass.utcfromtimestamp,\r
- insane)\r
- @unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")\r
- def test_negative_float_fromtimestamp(self):\r
- # The result is tz-dependent; at least test that this doesn't\r
- # fail (like it did before bug 1646728 was fixed).\r
- self.theclass.fromtimestamp(-1.05)\r
-\r
- @unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")\r
- def test_negative_float_utcfromtimestamp(self):\r
- d = self.theclass.utcfromtimestamp(-1.05)\r
- self.assertEqual(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))\r
-\r
- def test_utcnow(self):\r
- import time\r
-\r
- # Call it a success if utcnow() and utcfromtimestamp() are within\r
- # a second of each other.\r
- tolerance = timedelta(seconds=1)\r
- for dummy in range(3):\r
- from_now = self.theclass.utcnow()\r
- from_timestamp = self.theclass.utcfromtimestamp(time.time())\r
- if abs(from_timestamp - from_now) <= tolerance:\r
- break\r
- # Else try again a few times.\r
- self.assertTrue(abs(from_timestamp - from_now) <= tolerance)\r
-\r
- def test_strptime(self):\r
- import _strptime\r
-\r
- string = '2004-12-01 13:02:47.197'\r
- format = '%Y-%m-%d %H:%M:%S.%f'\r
- result, frac = _strptime._strptime(string, format)\r
- expected = self.theclass(*(result[0:6]+(frac,)))\r
- got = self.theclass.strptime(string, format)\r
- self.assertEqual(expected, got)\r
-\r
- def test_more_timetuple(self):\r
- # This tests fields beyond those tested by the TestDate.test_timetuple.\r
- t = self.theclass(2004, 12, 31, 6, 22, 33)\r
- self.assertEqual(t.timetuple(), (2004, 12, 31, 6, 22, 33, 4, 366, -1))\r
- self.assertEqual(t.timetuple(),\r
- (t.year, t.month, t.day,\r
- t.hour, t.minute, t.second,\r
- t.weekday(),\r
- t.toordinal() - date(t.year, 1, 1).toordinal() + 1,\r
- -1))\r
- tt = t.timetuple()\r
- self.assertEqual(tt.tm_year, t.year)\r
- self.assertEqual(tt.tm_mon, t.month)\r
- self.assertEqual(tt.tm_mday, t.day)\r
- self.assertEqual(tt.tm_hour, t.hour)\r
- self.assertEqual(tt.tm_min, t.minute)\r
- self.assertEqual(tt.tm_sec, t.second)\r
- self.assertEqual(tt.tm_wday, t.weekday())\r
- self.assertEqual(tt.tm_yday, t.toordinal() -\r
- date(t.year, 1, 1).toordinal() + 1)\r
- self.assertEqual(tt.tm_isdst, -1)\r
-\r
- def test_more_strftime(self):\r
- # This tests fields beyond those tested by the TestDate.test_strftime.\r
- t = self.theclass(2004, 12, 31, 6, 22, 33, 47)\r
- self.assertEqual(t.strftime("%m %d %y %f %S %M %H %j"),\r
- "12 31 04 000047 33 22 06 366")\r
-\r
- def test_extract(self):\r
- dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234)\r
- self.assertEqual(dt.date(), date(2002, 3, 4))\r
- self.assertEqual(dt.time(), time(18, 45, 3, 1234))\r
-\r
- def test_combine(self):\r
- d = date(2002, 3, 4)\r
- t = time(18, 45, 3, 1234)\r
- expected = self.theclass(2002, 3, 4, 18, 45, 3, 1234)\r
- combine = self.theclass.combine\r
- dt = combine(d, t)\r
- self.assertEqual(dt, expected)\r
-\r
- dt = combine(time=t, date=d)\r
- self.assertEqual(dt, expected)\r
-\r
- self.assertEqual(d, dt.date())\r
- self.assertEqual(t, dt.time())\r
- self.assertEqual(dt, combine(dt.date(), dt.time()))\r
-\r
- self.assertRaises(TypeError, combine) # need an arg\r
- self.assertRaises(TypeError, combine, d) # need two args\r
- self.assertRaises(TypeError, combine, t, d) # args reversed\r
- self.assertRaises(TypeError, combine, d, t, 1) # too many args\r
- self.assertRaises(TypeError, combine, "date", "time") # wrong types\r
-\r
- def test_replace(self):\r
- cls = self.theclass\r
- args = [1, 2, 3, 4, 5, 6, 7]\r
- base = cls(*args)\r
- self.assertEqual(base, base.replace())\r
-\r
- i = 0\r
- for name, newval in (("year", 2),\r
- ("month", 3),\r
- ("day", 4),\r
- ("hour", 5),\r
- ("minute", 6),\r
- ("second", 7),\r
- ("microsecond", 8)):\r
- newargs = args[:]\r
- newargs[i] = newval\r
- expected = cls(*newargs)\r
- got = base.replace(**{name: newval})\r
- self.assertEqual(expected, got)\r
- i += 1\r
-\r
- # Out of bounds.\r
- base = cls(2000, 2, 29)\r
- self.assertRaises(ValueError, base.replace, year=2001)\r
-\r
- def test_astimezone(self):\r
- # Pretty boring! The TZ test is more interesting here. astimezone()\r
- # simply can't be applied to a naive object.\r
- dt = self.theclass.now()\r
- f = FixedOffset(44, "")\r
- self.assertRaises(TypeError, dt.astimezone) # not enough args\r
- self.assertRaises(TypeError, dt.astimezone, f, f) # too many args\r
- self.assertRaises(TypeError, dt.astimezone, dt) # arg wrong type\r
- self.assertRaises(ValueError, dt.astimezone, f) # naive\r
- self.assertRaises(ValueError, dt.astimezone, tz=f) # naive\r
-\r
- class Bogus(tzinfo):\r
- def utcoffset(self, dt): return None\r
- def dst(self, dt): return timedelta(0)\r
- bog = Bogus()\r
- self.assertRaises(ValueError, dt.astimezone, bog) # naive\r
-\r
- class AlsoBogus(tzinfo):\r
- def utcoffset(self, dt): return timedelta(0)\r
- def dst(self, dt): return None\r
- alsobog = AlsoBogus()\r
- self.assertRaises(ValueError, dt.astimezone, alsobog) # also naive\r
-\r
- def test_subclass_datetime(self):\r
-\r
- class C(self.theclass):\r
- theAnswer = 42\r
-\r
- def __new__(cls, *args, **kws):\r
- temp = kws.copy()\r
- extra = temp.pop('extra')\r
- result = self.theclass.__new__(cls, *args, **temp)\r
- result.extra = extra\r
- return result\r
-\r
- def newmeth(self, start):\r
- return start + self.year + self.month + self.second\r
-\r
- args = 2003, 4, 14, 12, 13, 41\r
-\r
- dt1 = self.theclass(*args)\r
- dt2 = C(*args, **{'extra': 7})\r
-\r
- self.assertEqual(dt2.__class__, C)\r
- self.assertEqual(dt2.theAnswer, 42)\r
- self.assertEqual(dt2.extra, 7)\r
- self.assertEqual(dt1.toordinal(), dt2.toordinal())\r
- self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month +\r
- dt1.second - 7)\r
-\r
-class SubclassTime(time):\r
- sub_var = 1\r
-\r
-class TestTime(HarmlessMixedComparison, unittest.TestCase):\r
-\r
- theclass = time\r
-\r
- def test_basic_attributes(self):\r
- t = self.theclass(12, 0)\r
- self.assertEqual(t.hour, 12)\r
- self.assertEqual(t.minute, 0)\r
- self.assertEqual(t.second, 0)\r
- self.assertEqual(t.microsecond, 0)\r
-\r
- def test_basic_attributes_nonzero(self):\r
- # Make sure all attributes are non-zero so bugs in\r
- # bit-shifting access show up.\r
- t = self.theclass(12, 59, 59, 8000)\r
- self.assertEqual(t.hour, 12)\r
- self.assertEqual(t.minute, 59)\r
- self.assertEqual(t.second, 59)\r
- self.assertEqual(t.microsecond, 8000)\r
-\r
- def test_roundtrip(self):\r
- t = self.theclass(1, 2, 3, 4)\r
-\r
- # Verify t -> string -> time identity.\r
- s = repr(t)\r
- self.assertTrue(s.startswith('datetime.'))\r
- s = s[9:]\r
- t2 = eval(s)\r
- self.assertEqual(t, t2)\r
-\r
- # Verify identity via reconstructing from pieces.\r
- t2 = self.theclass(t.hour, t.minute, t.second,\r
- t.microsecond)\r
- self.assertEqual(t, t2)\r
-\r
- def test_comparing(self):\r
- args = [1, 2, 3, 4]\r
- t1 = self.theclass(*args)\r
- t2 = self.theclass(*args)\r
- self.assertTrue(t1 == t2)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t1 >= t2)\r
- self.assertTrue(not t1 != t2)\r
- self.assertTrue(not t1 < t2)\r
- self.assertTrue(not t1 > t2)\r
- self.assertEqual(cmp(t1, t2), 0)\r
- self.assertEqual(cmp(t2, t1), 0)\r
-\r
- for i in range(len(args)):\r
- newargs = args[:]\r
- newargs[i] = args[i] + 1\r
- t2 = self.theclass(*newargs) # this is larger than t1\r
- self.assertTrue(t1 < t2)\r
- self.assertTrue(t2 > t1)\r
- self.assertTrue(t1 <= t2)\r
- self.assertTrue(t2 >= t1)\r
- self.assertTrue(t1 != t2)\r
- self.assertTrue(t2 != t1)\r
- self.assertTrue(not t1 == t2)\r
- self.assertTrue(not t2 == t1)\r
- self.assertTrue(not t1 > t2)\r
- self.assertTrue(not t2 < t1)\r
- self.assertTrue(not t1 >= t2)\r
- self.assertTrue(not t2 <= t1)\r
- self.assertEqual(cmp(t1, t2), -1)\r
- self.assertEqual(cmp(t2, t1), 1)\r
-\r
- for badarg in OTHERSTUFF:\r
- self.assertEqual(t1 == badarg, False)\r
- self.assertEqual(t1 != badarg, True)\r
- self.assertEqual(badarg == t1, False)\r
- self.assertEqual(badarg != t1, True)\r
-\r
- self.assertRaises(TypeError, lambda: t1 <= badarg)\r
- self.assertRaises(TypeError, lambda: t1 < badarg)\r
- self.assertRaises(TypeError, lambda: t1 > badarg)\r
- self.assertRaises(TypeError, lambda: t1 >= badarg)\r
- self.assertRaises(TypeError, lambda: badarg <= t1)\r
- self.assertRaises(TypeError, lambda: badarg < t1)\r
- self.assertRaises(TypeError, lambda: badarg > t1)\r
- self.assertRaises(TypeError, lambda: badarg >= t1)\r
-\r
- def test_bad_constructor_arguments(self):\r
- # bad hours\r
- self.theclass(0, 0) # no exception\r
- self.theclass(23, 0) # no exception\r
- self.assertRaises(ValueError, self.theclass, -1, 0)\r
- self.assertRaises(ValueError, self.theclass, 24, 0)\r
- # bad minutes\r
- self.theclass(23, 0) # no exception\r
- self.theclass(23, 59) # no exception\r
- self.assertRaises(ValueError, self.theclass, 23, -1)\r
- self.assertRaises(ValueError, self.theclass, 23, 60)\r
- # bad seconds\r
- self.theclass(23, 59, 0) # no exception\r
- self.theclass(23, 59, 59) # no exception\r
- self.assertRaises(ValueError, self.theclass, 23, 59, -1)\r
- self.assertRaises(ValueError, self.theclass, 23, 59, 60)\r
- # bad microseconds\r
- self.theclass(23, 59, 59, 0) # no exception\r
- self.theclass(23, 59, 59, 999999) # no exception\r
- self.assertRaises(ValueError, self.theclass, 23, 59, 59, -1)\r
- self.assertRaises(ValueError, self.theclass, 23, 59, 59, 1000000)\r
-\r
- def test_hash_equality(self):\r
- d = self.theclass(23, 30, 17)\r
- e = self.theclass(23, 30, 17)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- d = self.theclass(0, 5, 17)\r
- e = self.theclass(0, 5, 17)\r
- self.assertEqual(d, e)\r
- self.assertEqual(hash(d), hash(e))\r
-\r
- dic = {d: 1}\r
- dic[e] = 2\r
- self.assertEqual(len(dic), 1)\r
- self.assertEqual(dic[d], 2)\r
- self.assertEqual(dic[e], 2)\r
-\r
- def test_isoformat(self):\r
- t = self.theclass(4, 5, 1, 123)\r
- self.assertEqual(t.isoformat(), "04:05:01.000123")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass()\r
- self.assertEqual(t.isoformat(), "00:00:00")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=1)\r
- self.assertEqual(t.isoformat(), "00:00:00.000001")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=10)\r
- self.assertEqual(t.isoformat(), "00:00:00.000010")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=100)\r
- self.assertEqual(t.isoformat(), "00:00:00.000100")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=1000)\r
- self.assertEqual(t.isoformat(), "00:00:00.001000")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=10000)\r
- self.assertEqual(t.isoformat(), "00:00:00.010000")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- t = self.theclass(microsecond=100000)\r
- self.assertEqual(t.isoformat(), "00:00:00.100000")\r
- self.assertEqual(t.isoformat(), str(t))\r
-\r
- def test_1653736(self):\r
- # verify it doesn't accept extra keyword arguments\r
- t = self.theclass(second=1)\r
- self.assertRaises(TypeError, t.isoformat, foo=3)\r
-\r
- def test_strftime(self):\r
- t = self.theclass(1, 2, 3, 4)\r
- self.assertEqual(t.strftime('%H %M %S %f'), "01 02 03 000004")\r
- # A naive object replaces %z and %Z with empty strings.\r
- self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")\r
-\r
- def test_format(self):\r
- t = self.theclass(1, 2, 3, 4)\r
- self.assertEqual(t.__format__(''), str(t))\r
-\r
- # check that a derived class's __str__() gets called\r
- class A(self.theclass):\r
- def __str__(self):\r
- return 'A'\r
- a = A(1, 2, 3, 4)\r
- self.assertEqual(a.__format__(''), 'A')\r
-\r
- # check that a derived class's strftime gets called\r
- class B(self.theclass):\r
- def strftime(self, format_spec):\r
- return 'B'\r
- b = B(1, 2, 3, 4)\r
- self.assertEqual(b.__format__(''), str(t))\r
-\r
- for fmt in ['%H %M %S',\r
- ]:\r
- self.assertEqual(t.__format__(fmt), t.strftime(fmt))\r
- self.assertEqual(a.__format__(fmt), t.strftime(fmt))\r
- self.assertEqual(b.__format__(fmt), 'B')\r
-\r
- def test_str(self):\r
- self.assertEqual(str(self.theclass(1, 2, 3, 4)), "01:02:03.000004")\r
- self.assertEqual(str(self.theclass(10, 2, 3, 4000)), "10:02:03.004000")\r
- self.assertEqual(str(self.theclass(0, 2, 3, 400000)), "00:02:03.400000")\r
- self.assertEqual(str(self.theclass(12, 2, 3, 0)), "12:02:03")\r
- self.assertEqual(str(self.theclass(23, 15, 0, 0)), "23:15:00")\r
-\r
- def test_repr(self):\r
- name = 'datetime.' + self.theclass.__name__\r
- self.assertEqual(repr(self.theclass(1, 2, 3, 4)),\r
- "%s(1, 2, 3, 4)" % name)\r
- self.assertEqual(repr(self.theclass(10, 2, 3, 4000)),\r
- "%s(10, 2, 3, 4000)" % name)\r
- self.assertEqual(repr(self.theclass(0, 2, 3, 400000)),\r
- "%s(0, 2, 3, 400000)" % name)\r
- self.assertEqual(repr(self.theclass(12, 2, 3, 0)),\r
- "%s(12, 2, 3)" % name)\r
- self.assertEqual(repr(self.theclass(23, 15, 0, 0)),\r
- "%s(23, 15)" % name)\r
-\r
- def test_resolution_info(self):\r
- self.assertIsInstance(self.theclass.min, self.theclass)\r
- self.assertIsInstance(self.theclass.max, self.theclass)\r
- self.assertIsInstance(self.theclass.resolution, timedelta)\r
- self.assertTrue(self.theclass.max > self.theclass.min)\r
-\r
- def test_pickling(self):\r
- args = 20, 59, 16, 64**2\r
- orig = self.theclass(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_pickling_subclass_time(self):\r
- args = 20, 59, 16, 64**2\r
- orig = SubclassTime(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- def test_bool(self):\r
- cls = self.theclass\r
- self.assertTrue(cls(1))\r
- self.assertTrue(cls(0, 1))\r
- self.assertTrue(cls(0, 0, 1))\r
- self.assertTrue(cls(0, 0, 0, 1))\r
- self.assertTrue(not cls(0))\r
- self.assertTrue(not cls())\r
-\r
- def test_replace(self):\r
- cls = self.theclass\r
- args = [1, 2, 3, 4]\r
- base = cls(*args)\r
- self.assertEqual(base, base.replace())\r
-\r
- i = 0\r
- for name, newval in (("hour", 5),\r
- ("minute", 6),\r
- ("second", 7),\r
- ("microsecond", 8)):\r
- newargs = args[:]\r
- newargs[i] = newval\r
- expected = cls(*newargs)\r
- got = base.replace(**{name: newval})\r
- self.assertEqual(expected, got)\r
- i += 1\r
-\r
- # Out of bounds.\r
- base = cls(1)\r
- self.assertRaises(ValueError, base.replace, hour=24)\r
- self.assertRaises(ValueError, base.replace, minute=-1)\r
- self.assertRaises(ValueError, base.replace, second=100)\r
- self.assertRaises(ValueError, base.replace, microsecond=1000000)\r
-\r
- def test_subclass_time(self):\r
-\r
- class C(self.theclass):\r
- theAnswer = 42\r
-\r
- def __new__(cls, *args, **kws):\r
- temp = kws.copy()\r
- extra = temp.pop('extra')\r
- result = self.theclass.__new__(cls, *args, **temp)\r
- result.extra = extra\r
- return result\r
-\r
- def newmeth(self, start):\r
- return start + self.hour + self.second\r
-\r
- args = 4, 5, 6\r
-\r
- dt1 = self.theclass(*args)\r
- dt2 = C(*args, **{'extra': 7})\r
-\r
- self.assertEqual(dt2.__class__, C)\r
- self.assertEqual(dt2.theAnswer, 42)\r
- self.assertEqual(dt2.extra, 7)\r
- self.assertEqual(dt1.isoformat(), dt2.isoformat())\r
- self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)\r
-\r
- def test_backdoor_resistance(self):\r
- # see TestDate.test_backdoor_resistance().\r
- base = '2:59.0'\r
- for hour_byte in ' ', '9', chr(24), '\xff':\r
- self.assertRaises(TypeError, self.theclass,\r
- hour_byte + base[1:])\r
-\r
-# A mixin for classes with a tzinfo= argument. Subclasses must define\r
-# theclass as a class atribute, and theclass(1, 1, 1, tzinfo=whatever)\r
-# must be legit (which is true for time and datetime).\r
-class TZInfoBase:\r
-\r
- def test_argument_passing(self):\r
- cls = self.theclass\r
- # A datetime passes itself on, a time passes None.\r
- class introspective(tzinfo):\r
- def tzname(self, dt): return dt and "real" or "none"\r
- def utcoffset(self, dt):\r
- return timedelta(minutes = dt and 42 or -42)\r
- dst = utcoffset\r
-\r
- obj = cls(1, 2, 3, tzinfo=introspective())\r
-\r
- expected = cls is time and "none" or "real"\r
- self.assertEqual(obj.tzname(), expected)\r
-\r
- expected = timedelta(minutes=(cls is time and -42 or 42))\r
- self.assertEqual(obj.utcoffset(), expected)\r
- self.assertEqual(obj.dst(), expected)\r
-\r
- def test_bad_tzinfo_classes(self):\r
- cls = self.theclass\r
- self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=12)\r
-\r
- class NiceTry(object):\r
- def __init__(self): pass\r
- def utcoffset(self, dt): pass\r
- self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=NiceTry)\r
-\r
- class BetterTry(tzinfo):\r
- def __init__(self): pass\r
- def utcoffset(self, dt): pass\r
- b = BetterTry()\r
- t = cls(1, 1, 1, tzinfo=b)\r
- self.assertTrue(t.tzinfo is b)\r
-\r
- def test_utc_offset_out_of_bounds(self):\r
- class Edgy(tzinfo):\r
- def __init__(self, offset):\r
- self.offset = timedelta(minutes=offset)\r
- def utcoffset(self, dt):\r
- return self.offset\r
-\r
- cls = self.theclass\r
- for offset, legit in ((-1440, False),\r
- (-1439, True),\r
- (1439, True),\r
- (1440, False)):\r
- if cls is time:\r
- t = cls(1, 2, 3, tzinfo=Edgy(offset))\r
- elif cls is datetime:\r
- t = cls(6, 6, 6, 1, 2, 3, tzinfo=Edgy(offset))\r
- else:\r
- assert 0, "impossible"\r
- if legit:\r
- aofs = abs(offset)\r
- h, m = divmod(aofs, 60)\r
- tag = "%c%02d:%02d" % (offset < 0 and '-' or '+', h, m)\r
- if isinstance(t, datetime):\r
- t = t.timetz()\r
- self.assertEqual(str(t), "01:02:03" + tag)\r
- else:\r
- self.assertRaises(ValueError, str, t)\r
-\r
- def test_tzinfo_classes(self):\r
- cls = self.theclass\r
- class C1(tzinfo):\r
- def utcoffset(self, dt): return None\r
- def dst(self, dt): return None\r
- def tzname(self, dt): return None\r
- for t in (cls(1, 1, 1),\r
- cls(1, 1, 1, tzinfo=None),\r
- cls(1, 1, 1, tzinfo=C1())):\r
- self.assertTrue(t.utcoffset() is None)\r
- self.assertTrue(t.dst() is None)\r
- self.assertTrue(t.tzname() is None)\r
-\r
- class C3(tzinfo):\r
- def utcoffset(self, dt): return timedelta(minutes=-1439)\r
- def dst(self, dt): return timedelta(minutes=1439)\r
- def tzname(self, dt): return "aname"\r
- t = cls(1, 1, 1, tzinfo=C3())\r
- self.assertEqual(t.utcoffset(), timedelta(minutes=-1439))\r
- self.assertEqual(t.dst(), timedelta(minutes=1439))\r
- self.assertEqual(t.tzname(), "aname")\r
-\r
- # Wrong types.\r
- class C4(tzinfo):\r
- def utcoffset(self, dt): return "aname"\r
- def dst(self, dt): return 7\r
- def tzname(self, dt): return 0\r
- t = cls(1, 1, 1, tzinfo=C4())\r
- self.assertRaises(TypeError, t.utcoffset)\r
- self.assertRaises(TypeError, t.dst)\r
- self.assertRaises(TypeError, t.tzname)\r
-\r
- # Offset out of range.\r
- class C6(tzinfo):\r
- def utcoffset(self, dt): return timedelta(hours=-24)\r
- def dst(self, dt): return timedelta(hours=24)\r
- t = cls(1, 1, 1, tzinfo=C6())\r
- self.assertRaises(ValueError, t.utcoffset)\r
- self.assertRaises(ValueError, t.dst)\r
-\r
- # Not a whole number of minutes.\r
- class C7(tzinfo):\r
- def utcoffset(self, dt): return timedelta(seconds=61)\r
- def dst(self, dt): return timedelta(microseconds=-81)\r
- t = cls(1, 1, 1, tzinfo=C7())\r
- self.assertRaises(ValueError, t.utcoffset)\r
- self.assertRaises(ValueError, t.dst)\r
-\r
- def test_aware_compare(self):\r
- cls = self.theclass\r
-\r
- # Ensure that utcoffset() gets ignored if the comparands have\r
- # the same tzinfo member.\r
- class OperandDependentOffset(tzinfo):\r
- def utcoffset(self, t):\r
- if t.minute < 10:\r
- # d0 and d1 equal after adjustment\r
- return timedelta(minutes=t.minute)\r
- else:\r
- # d2 off in the weeds\r
- return timedelta(minutes=59)\r
-\r
- base = cls(8, 9, 10, tzinfo=OperandDependentOffset())\r
- d0 = base.replace(minute=3)\r
- d1 = base.replace(minute=9)\r
- d2 = base.replace(minute=11)\r
- for x in d0, d1, d2:\r
- for y in d0, d1, d2:\r
- got = cmp(x, y)\r
- expected = cmp(x.minute, y.minute)\r
- self.assertEqual(got, expected)\r
-\r
- # However, if they're different members, uctoffset is not ignored.\r
- # Note that a time can't actually have an operand-depedent offset,\r
- # though (and time.utcoffset() passes None to tzinfo.utcoffset()),\r
- # so skip this test for time.\r
- if cls is not time:\r
- d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())\r
- d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())\r
- d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())\r
- for x in d0, d1, d2:\r
- for y in d0, d1, d2:\r
- got = cmp(x, y)\r
- if (x is d0 or x is d1) and (y is d0 or y is d1):\r
- expected = 0\r
- elif x is y is d2:\r
- expected = 0\r
- elif x is d2:\r
- expected = -1\r
- else:\r
- assert y is d2\r
- expected = 1\r
- self.assertEqual(got, expected)\r
-\r
-\r
-# Testing time objects with a non-None tzinfo.\r
-class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):\r
- theclass = time\r
-\r
- def test_empty(self):\r
- t = self.theclass()\r
- self.assertEqual(t.hour, 0)\r
- self.assertEqual(t.minute, 0)\r
- self.assertEqual(t.second, 0)\r
- self.assertEqual(t.microsecond, 0)\r
- self.assertTrue(t.tzinfo is None)\r
-\r
- def test_zones(self):\r
- est = FixedOffset(-300, "EST", 1)\r
- utc = FixedOffset(0, "UTC", -2)\r
- met = FixedOffset(60, "MET", 3)\r
- t1 = time( 7, 47, tzinfo=est)\r
- t2 = time(12, 47, tzinfo=utc)\r
- t3 = time(13, 47, tzinfo=met)\r
- t4 = time(microsecond=40)\r
- t5 = time(microsecond=40, tzinfo=utc)\r
-\r
- self.assertEqual(t1.tzinfo, est)\r
- self.assertEqual(t2.tzinfo, utc)\r
- self.assertEqual(t3.tzinfo, met)\r
- self.assertTrue(t4.tzinfo is None)\r
- self.assertEqual(t5.tzinfo, utc)\r
-\r
- self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))\r
- self.assertEqual(t2.utcoffset(), timedelta(minutes=0))\r
- self.assertEqual(t3.utcoffset(), timedelta(minutes=60))\r
- self.assertTrue(t4.utcoffset() is None)\r
- self.assertRaises(TypeError, t1.utcoffset, "no args")\r
-\r
- self.assertEqual(t1.tzname(), "EST")\r
- self.assertEqual(t2.tzname(), "UTC")\r
- self.assertEqual(t3.tzname(), "MET")\r
- self.assertTrue(t4.tzname() is None)\r
- self.assertRaises(TypeError, t1.tzname, "no args")\r
-\r
- self.assertEqual(t1.dst(), timedelta(minutes=1))\r
- self.assertEqual(t2.dst(), timedelta(minutes=-2))\r
- self.assertEqual(t3.dst(), timedelta(minutes=3))\r
- self.assertTrue(t4.dst() is None)\r
- self.assertRaises(TypeError, t1.dst, "no args")\r
-\r
- self.assertEqual(hash(t1), hash(t2))\r
- self.assertEqual(hash(t1), hash(t3))\r
- self.assertEqual(hash(t2), hash(t3))\r
-\r
- self.assertEqual(t1, t2)\r
- self.assertEqual(t1, t3)\r
- self.assertEqual(t2, t3)\r
- self.assertRaises(TypeError, lambda: t4 == t5) # mixed tz-aware & naive\r
- self.assertRaises(TypeError, lambda: t4 < t5) # mixed tz-aware & naive\r
- self.assertRaises(TypeError, lambda: t5 < t4) # mixed tz-aware & naive\r
-\r
- self.assertEqual(str(t1), "07:47:00-05:00")\r
- self.assertEqual(str(t2), "12:47:00+00:00")\r
- self.assertEqual(str(t3), "13:47:00+01:00")\r
- self.assertEqual(str(t4), "00:00:00.000040")\r
- self.assertEqual(str(t5), "00:00:00.000040+00:00")\r
-\r
- self.assertEqual(t1.isoformat(), "07:47:00-05:00")\r
- self.assertEqual(t2.isoformat(), "12:47:00+00:00")\r
- self.assertEqual(t3.isoformat(), "13:47:00+01:00")\r
- self.assertEqual(t4.isoformat(), "00:00:00.000040")\r
- self.assertEqual(t5.isoformat(), "00:00:00.000040+00:00")\r
-\r
- d = 'datetime.time'\r
- self.assertEqual(repr(t1), d + "(7, 47, tzinfo=est)")\r
- self.assertEqual(repr(t2), d + "(12, 47, tzinfo=utc)")\r
- self.assertEqual(repr(t3), d + "(13, 47, tzinfo=met)")\r
- self.assertEqual(repr(t4), d + "(0, 0, 0, 40)")\r
- self.assertEqual(repr(t5), d + "(0, 0, 0, 40, tzinfo=utc)")\r
-\r
- self.assertEqual(t1.strftime("%H:%M:%S %%Z=%Z %%z=%z"),\r
- "07:47:00 %Z=EST %z=-0500")\r
- self.assertEqual(t2.strftime("%H:%M:%S %Z %z"), "12:47:00 UTC +0000")\r
- self.assertEqual(t3.strftime("%H:%M:%S %Z %z"), "13:47:00 MET +0100")\r
-\r
- yuck = FixedOffset(-1439, "%z %Z %%z%%Z")\r
- t1 = time(23, 59, tzinfo=yuck)\r
- self.assertEqual(t1.strftime("%H:%M %%Z='%Z' %%z='%z'"),\r
- "23:59 %Z='%z %Z %%z%%Z' %z='-2359'")\r
-\r
- # Check that an invalid tzname result raises an exception.\r
- class Badtzname(tzinfo):\r
- def tzname(self, dt): return 42\r
- t = time(2, 3, 4, tzinfo=Badtzname())\r
- self.assertEqual(t.strftime("%H:%M:%S"), "02:03:04")\r
- self.assertRaises(TypeError, t.strftime, "%Z")\r
-\r
- def test_hash_edge_cases(self):\r
- # Offsets that overflow a basic time.\r
- t1 = self.theclass(0, 1, 2, 3, tzinfo=FixedOffset(1439, ""))\r
- t2 = self.theclass(0, 0, 2, 3, tzinfo=FixedOffset(1438, ""))\r
- self.assertEqual(hash(t1), hash(t2))\r
-\r
- t1 = self.theclass(23, 58, 6, 100, tzinfo=FixedOffset(-1000, ""))\r
- t2 = self.theclass(23, 48, 6, 100, tzinfo=FixedOffset(-1010, ""))\r
- self.assertEqual(hash(t1), hash(t2))\r
-\r
- def test_pickling(self):\r
- # Try one without a tzinfo.\r
- args = 20, 59, 16, 64**2\r
- orig = self.theclass(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- # Try one with a tzinfo.\r
- tinfo = PicklableFixedOffset(-300, 'cookie')\r
- orig = self.theclass(5, 6, 7, tzinfo=tinfo)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
- self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)\r
- self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))\r
- self.assertEqual(derived.tzname(), 'cookie')\r
-\r
- def test_more_bool(self):\r
- # Test cases with non-None tzinfo.\r
- cls = self.theclass\r
-\r
- t = cls(0, tzinfo=FixedOffset(-300, ""))\r
- self.assertTrue(t)\r
-\r
- t = cls(5, tzinfo=FixedOffset(-300, ""))\r
- self.assertTrue(t)\r
-\r
- t = cls(5, tzinfo=FixedOffset(300, ""))\r
- self.assertTrue(not t)\r
-\r
- t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))\r
- self.assertTrue(not t)\r
-\r
- # Mostly ensuring this doesn't overflow internally.\r
- t = cls(0, tzinfo=FixedOffset(23*60 + 59, ""))\r
- self.assertTrue(t)\r
-\r
- # But this should yield a value error -- the utcoffset is bogus.\r
- t = cls(0, tzinfo=FixedOffset(24*60, ""))\r
- self.assertRaises(ValueError, lambda: bool(t))\r
-\r
- # Likewise.\r
- t = cls(0, tzinfo=FixedOffset(-24*60, ""))\r
- self.assertRaises(ValueError, lambda: bool(t))\r
-\r
- def test_replace(self):\r
- cls = self.theclass\r
- z100 = FixedOffset(100, "+100")\r
- zm200 = FixedOffset(timedelta(minutes=-200), "-200")\r
- args = [1, 2, 3, 4, z100]\r
- base = cls(*args)\r
- self.assertEqual(base, base.replace())\r
-\r
- i = 0\r
- for name, newval in (("hour", 5),\r
- ("minute", 6),\r
- ("second", 7),\r
- ("microsecond", 8),\r
- ("tzinfo", zm200)):\r
- newargs = args[:]\r
- newargs[i] = newval\r
- expected = cls(*newargs)\r
- got = base.replace(**{name: newval})\r
- self.assertEqual(expected, got)\r
- i += 1\r
-\r
- # Ensure we can get rid of a tzinfo.\r
- self.assertEqual(base.tzname(), "+100")\r
- base2 = base.replace(tzinfo=None)\r
- self.assertTrue(base2.tzinfo is None)\r
- self.assertTrue(base2.tzname() is None)\r
-\r
- # Ensure we can add one.\r
- base3 = base2.replace(tzinfo=z100)\r
- self.assertEqual(base, base3)\r
- self.assertTrue(base.tzinfo is base3.tzinfo)\r
-\r
- # Out of bounds.\r
- base = cls(1)\r
- self.assertRaises(ValueError, base.replace, hour=24)\r
- self.assertRaises(ValueError, base.replace, minute=-1)\r
- self.assertRaises(ValueError, base.replace, second=100)\r
- self.assertRaises(ValueError, base.replace, microsecond=1000000)\r
-\r
- def test_mixed_compare(self):\r
- t1 = time(1, 2, 3)\r
- t2 = time(1, 2, 3)\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=None)\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=FixedOffset(None, ""))\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=FixedOffset(0, ""))\r
- self.assertRaises(TypeError, lambda: t1 == t2)\r
-\r
- # In time w/ identical tzinfo objects, utcoffset is ignored.\r
- class Varies(tzinfo):\r
- def __init__(self):\r
- self.offset = timedelta(minutes=22)\r
- def utcoffset(self, t):\r
- self.offset += timedelta(minutes=1)\r
- return self.offset\r
-\r
- v = Varies()\r
- t1 = t2.replace(tzinfo=v)\r
- t2 = t2.replace(tzinfo=v)\r
- self.assertEqual(t1.utcoffset(), timedelta(minutes=23))\r
- self.assertEqual(t2.utcoffset(), timedelta(minutes=24))\r
- self.assertEqual(t1, t2)\r
-\r
- # But if they're not identical, it isn't ignored.\r
- t2 = t2.replace(tzinfo=Varies())\r
- self.assertTrue(t1 < t2) # t1's offset counter still going up\r
-\r
- def test_subclass_timetz(self):\r
-\r
- class C(self.theclass):\r
- theAnswer = 42\r
-\r
- def __new__(cls, *args, **kws):\r
- temp = kws.copy()\r
- extra = temp.pop('extra')\r
- result = self.theclass.__new__(cls, *args, **temp)\r
- result.extra = extra\r
- return result\r
-\r
- def newmeth(self, start):\r
- return start + self.hour + self.second\r
-\r
- args = 4, 5, 6, 500, FixedOffset(-300, "EST", 1)\r
-\r
- dt1 = self.theclass(*args)\r
- dt2 = C(*args, **{'extra': 7})\r
-\r
- self.assertEqual(dt2.__class__, C)\r
- self.assertEqual(dt2.theAnswer, 42)\r
- self.assertEqual(dt2.extra, 7)\r
- self.assertEqual(dt1.utcoffset(), dt2.utcoffset())\r
- self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)\r
-\r
-\r
-# Testing datetime objects with a non-None tzinfo.\r
-\r
-class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):\r
- theclass = datetime\r
-\r
- def test_trivial(self):\r
- dt = self.theclass(1, 2, 3, 4, 5, 6, 7)\r
- self.assertEqual(dt.year, 1)\r
- self.assertEqual(dt.month, 2)\r
- self.assertEqual(dt.day, 3)\r
- self.assertEqual(dt.hour, 4)\r
- self.assertEqual(dt.minute, 5)\r
- self.assertEqual(dt.second, 6)\r
- self.assertEqual(dt.microsecond, 7)\r
- self.assertEqual(dt.tzinfo, None)\r
-\r
- def test_even_more_compare(self):\r
- # The test_compare() and test_more_compare() inherited from TestDate\r
- # and TestDateTime covered non-tzinfo cases.\r
-\r
- # Smallest possible after UTC adjustment.\r
- t1 = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))\r
- # Largest possible after UTC adjustment.\r
- t2 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,\r
- tzinfo=FixedOffset(-1439, ""))\r
-\r
- # Make sure those compare correctly, and w/o overflow.\r
- self.assertTrue(t1 < t2)\r
- self.assertTrue(t1 != t2)\r
- self.assertTrue(t2 > t1)\r
-\r
- self.assertTrue(t1 == t1)\r
- self.assertTrue(t2 == t2)\r
-\r
- # Equal afer adjustment.\r
- t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""))\r
- t2 = self.theclass(2, 1, 1, 3, 13, tzinfo=FixedOffset(3*60+13+2, ""))\r
- self.assertEqual(t1, t2)\r
-\r
- # Change t1 not to subtract a minute, and t1 should be larger.\r
- t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))\r
- self.assertTrue(t1 > t2)\r
-\r
- # Change t1 to subtract 2 minutes, and t1 should be smaller.\r
- t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))\r
- self.assertTrue(t1 < t2)\r
-\r
- # Back to the original t1, but make seconds resolve it.\r
- t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),\r
- second=1)\r
- self.assertTrue(t1 > t2)\r
-\r
- # Likewise, but make microseconds resolve it.\r
- t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),\r
- microsecond=1)\r
- self.assertTrue(t1 > t2)\r
-\r
- # Make t2 naive and it should fail.\r
- t2 = self.theclass.min\r
- self.assertRaises(TypeError, lambda: t1 == t2)\r
- self.assertEqual(t2, t2)\r
-\r
- # It's also naive if it has tzinfo but tzinfo.utcoffset() is None.\r
- class Naive(tzinfo):\r
- def utcoffset(self, dt): return None\r
- t2 = self.theclass(5, 6, 7, tzinfo=Naive())\r
- self.assertRaises(TypeError, lambda: t1 == t2)\r
- self.assertEqual(t2, t2)\r
-\r
- # OTOH, it's OK to compare two of these mixing the two ways of being\r
- # naive.\r
- t1 = self.theclass(5, 6, 7)\r
- self.assertEqual(t1, t2)\r
-\r
- # Try a bogus uctoffset.\r
- class Bogus(tzinfo):\r
- def utcoffset(self, dt):\r
- return timedelta(minutes=1440) # out of bounds\r
- t1 = self.theclass(2, 2, 2, tzinfo=Bogus())\r
- t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))\r
- self.assertRaises(ValueError, lambda: t1 == t2)\r
-\r
- def test_pickling(self):\r
- # Try one without a tzinfo.\r
- args = 6, 7, 23, 20, 59, 1, 64**2\r
- orig = self.theclass(*args)\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
-\r
- # Try one with a tzinfo.\r
- tinfo = PicklableFixedOffset(-300, 'cookie')\r
- orig = self.theclass(*args, **{'tzinfo': tinfo})\r
- derived = self.theclass(1, 1, 1, tzinfo=FixedOffset(0, "", 0))\r
- for pickler, unpickler, proto in pickle_choices:\r
- green = pickler.dumps(orig, proto)\r
- derived = unpickler.loads(green)\r
- self.assertEqual(orig, derived)\r
- self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)\r
- self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))\r
- self.assertEqual(derived.tzname(), 'cookie')\r
-\r
- def test_extreme_hashes(self):\r
- # If an attempt is made to hash these via subtracting the offset\r
- # then hashing a datetime object, OverflowError results. The\r
- # Python implementation used to blow up here.\r
- t = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))\r
- hash(t)\r
- t = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,\r
- tzinfo=FixedOffset(-1439, ""))\r
- hash(t)\r
-\r
- # OTOH, an OOB offset should blow up.\r
- t = self.theclass(5, 5, 5, tzinfo=FixedOffset(-1440, ""))\r
- self.assertRaises(ValueError, hash, t)\r
-\r
- def test_zones(self):\r
- est = FixedOffset(-300, "EST")\r
- utc = FixedOffset(0, "UTC")\r
- met = FixedOffset(60, "MET")\r
- t1 = datetime(2002, 3, 19, 7, 47, tzinfo=est)\r
- t2 = datetime(2002, 3, 19, 12, 47, tzinfo=utc)\r
- t3 = datetime(2002, 3, 19, 13, 47, tzinfo=met)\r
- self.assertEqual(t1.tzinfo, est)\r
- self.assertEqual(t2.tzinfo, utc)\r
- self.assertEqual(t3.tzinfo, met)\r
- self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))\r
- self.assertEqual(t2.utcoffset(), timedelta(minutes=0))\r
- self.assertEqual(t3.utcoffset(), timedelta(minutes=60))\r
- self.assertEqual(t1.tzname(), "EST")\r
- self.assertEqual(t2.tzname(), "UTC")\r
- self.assertEqual(t3.tzname(), "MET")\r
- self.assertEqual(hash(t1), hash(t2))\r
- self.assertEqual(hash(t1), hash(t3))\r
- self.assertEqual(hash(t2), hash(t3))\r
- self.assertEqual(t1, t2)\r
- self.assertEqual(t1, t3)\r
- self.assertEqual(t2, t3)\r
- self.assertEqual(str(t1), "2002-03-19 07:47:00-05:00")\r
- self.assertEqual(str(t2), "2002-03-19 12:47:00+00:00")\r
- self.assertEqual(str(t3), "2002-03-19 13:47:00+01:00")\r
- d = 'datetime.datetime(2002, 3, 19, '\r
- self.assertEqual(repr(t1), d + "7, 47, tzinfo=est)")\r
- self.assertEqual(repr(t2), d + "12, 47, tzinfo=utc)")\r
- self.assertEqual(repr(t3), d + "13, 47, tzinfo=met)")\r
-\r
- def test_combine(self):\r
- met = FixedOffset(60, "MET")\r
- d = date(2002, 3, 4)\r
- tz = time(18, 45, 3, 1234, tzinfo=met)\r
- dt = datetime.combine(d, tz)\r
- self.assertEqual(dt, datetime(2002, 3, 4, 18, 45, 3, 1234,\r
- tzinfo=met))\r
-\r
- def test_extract(self):\r
- met = FixedOffset(60, "MET")\r
- dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234, tzinfo=met)\r
- self.assertEqual(dt.date(), date(2002, 3, 4))\r
- self.assertEqual(dt.time(), time(18, 45, 3, 1234))\r
- self.assertEqual(dt.timetz(), time(18, 45, 3, 1234, tzinfo=met))\r
-\r
- def test_tz_aware_arithmetic(self):\r
- import random\r
-\r
- now = self.theclass.now()\r
- tz55 = FixedOffset(-330, "west 5:30")\r
- timeaware = now.time().replace(tzinfo=tz55)\r
- nowaware = self.theclass.combine(now.date(), timeaware)\r
- self.assertTrue(nowaware.tzinfo is tz55)\r
- self.assertEqual(nowaware.timetz(), timeaware)\r
-\r
- # Can't mix aware and non-aware.\r
- self.assertRaises(TypeError, lambda: now - nowaware)\r
- self.assertRaises(TypeError, lambda: nowaware - now)\r
-\r
- # And adding datetime's doesn't make sense, aware or not.\r
- self.assertRaises(TypeError, lambda: now + nowaware)\r
- self.assertRaises(TypeError, lambda: nowaware + now)\r
- self.assertRaises(TypeError, lambda: nowaware + nowaware)\r
-\r
- # Subtracting should yield 0.\r
- self.assertEqual(now - now, timedelta(0))\r
- self.assertEqual(nowaware - nowaware, timedelta(0))\r
-\r
- # Adding a delta should preserve tzinfo.\r
- delta = timedelta(weeks=1, minutes=12, microseconds=5678)\r
- nowawareplus = nowaware + delta\r
- self.assertTrue(nowaware.tzinfo is tz55)\r
- nowawareplus2 = delta + nowaware\r
- self.assertTrue(nowawareplus2.tzinfo is tz55)\r
- self.assertEqual(nowawareplus, nowawareplus2)\r
-\r
- # that - delta should be what we started with, and that - what we\r
- # started with should be delta.\r
- diff = nowawareplus - delta\r
- self.assertTrue(diff.tzinfo is tz55)\r
- self.assertEqual(nowaware, diff)\r
- self.assertRaises(TypeError, lambda: delta - nowawareplus)\r
- self.assertEqual(nowawareplus - nowaware, delta)\r
-\r
- # Make up a random timezone.\r
- tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone")\r
- # Attach it to nowawareplus.\r
- nowawareplus = nowawareplus.replace(tzinfo=tzr)\r
- self.assertTrue(nowawareplus.tzinfo is tzr)\r
- # Make sure the difference takes the timezone adjustments into account.\r
- got = nowaware - nowawareplus\r
- # Expected: (nowaware base - nowaware offset) -\r
- # (nowawareplus base - nowawareplus offset) =\r
- # (nowaware base - nowawareplus base) +\r
- # (nowawareplus offset - nowaware offset) =\r
- # -delta + nowawareplus offset - nowaware offset\r
- expected = nowawareplus.utcoffset() - nowaware.utcoffset() - delta\r
- self.assertEqual(got, expected)\r
-\r
- # Try max possible difference.\r
- min = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, "min"))\r
- max = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,\r
- tzinfo=FixedOffset(-1439, "max"))\r
- maxdiff = max - min\r
- self.assertEqual(maxdiff, self.theclass.max - self.theclass.min +\r
- timedelta(minutes=2*1439))\r
-\r
- def test_tzinfo_now(self):\r
- meth = self.theclass.now\r
- # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).\r
- base = meth()\r
- # Try with and without naming the keyword.\r
- off42 = FixedOffset(42, "42")\r
- another = meth(off42)\r
- again = meth(tz=off42)\r
- self.assertTrue(another.tzinfo is again.tzinfo)\r
- self.assertEqual(another.utcoffset(), timedelta(minutes=42))\r
- # Bad argument with and w/o naming the keyword.\r
- self.assertRaises(TypeError, meth, 16)\r
- self.assertRaises(TypeError, meth, tzinfo=16)\r
- # Bad keyword name.\r
- self.assertRaises(TypeError, meth, tinfo=off42)\r
- # Too many args.\r
- self.assertRaises(TypeError, meth, off42, off42)\r
-\r
- # We don't know which time zone we're in, and don't have a tzinfo\r
- # class to represent it, so seeing whether a tz argument actually\r
- # does a conversion is tricky.\r
- weirdtz = FixedOffset(timedelta(hours=15, minutes=58), "weirdtz", 0)\r
- utc = FixedOffset(0, "utc", 0)\r
- for dummy in range(3):\r
- now = datetime.now(weirdtz)\r
- self.assertTrue(now.tzinfo is weirdtz)\r
- utcnow = datetime.utcnow().replace(tzinfo=utc)\r
- now2 = utcnow.astimezone(weirdtz)\r
- if abs(now - now2) < timedelta(seconds=30):\r
- break\r
- # Else the code is broken, or more than 30 seconds passed between\r
- # calls; assuming the latter, just try again.\r
- else:\r
- # Three strikes and we're out.\r
- self.fail("utcnow(), now(tz), or astimezone() may be broken")\r
-\r
- def test_tzinfo_fromtimestamp(self):\r
- import time\r
- meth = self.theclass.fromtimestamp\r
- ts = time.time()\r
- # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).\r
- base = meth(ts)\r
- # Try with and without naming the keyword.\r
- off42 = FixedOffset(42, "42")\r
- another = meth(ts, off42)\r
- again = meth(ts, tz=off42)\r
- self.assertTrue(another.tzinfo is again.tzinfo)\r
- self.assertEqual(another.utcoffset(), timedelta(minutes=42))\r
- # Bad argument with and w/o naming the keyword.\r
- self.assertRaises(TypeError, meth, ts, 16)\r
- self.assertRaises(TypeError, meth, ts, tzinfo=16)\r
- # Bad keyword name.\r
- self.assertRaises(TypeError, meth, ts, tinfo=off42)\r
- # Too many args.\r
- self.assertRaises(TypeError, meth, ts, off42, off42)\r
- # Too few args.\r
- self.assertRaises(TypeError, meth)\r
-\r
- # Try to make sure tz= actually does some conversion.\r
- timestamp = 1000000000\r
- utcdatetime = datetime.utcfromtimestamp(timestamp)\r
- # In POSIX (epoch 1970), that's 2001-09-09 01:46:40 UTC, give or take.\r
- # But on some flavor of Mac, it's nowhere near that. So we can't have\r
- # any idea here what time that actually is, we can only test that\r
- # relative changes match.\r
- utcoffset = timedelta(hours=-15, minutes=39) # arbitrary, but not zero\r
- tz = FixedOffset(utcoffset, "tz", 0)\r
- expected = utcdatetime + utcoffset\r
- got = datetime.fromtimestamp(timestamp, tz)\r
- self.assertEqual(expected, got.replace(tzinfo=None))\r
-\r
- def test_tzinfo_utcnow(self):\r
- meth = self.theclass.utcnow\r
- # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).\r
- base = meth()\r
- # Try with and without naming the keyword; for whatever reason,\r
- # utcnow() doesn't accept a tzinfo argument.\r
- off42 = FixedOffset(42, "42")\r
- self.assertRaises(TypeError, meth, off42)\r
- self.assertRaises(TypeError, meth, tzinfo=off42)\r
-\r
- def test_tzinfo_utcfromtimestamp(self):\r
- import time\r
- meth = self.theclass.utcfromtimestamp\r
- ts = time.time()\r
- # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).\r
- base = meth(ts)\r
- # Try with and without naming the keyword; for whatever reason,\r
- # utcfromtimestamp() doesn't accept a tzinfo argument.\r
- off42 = FixedOffset(42, "42")\r
- self.assertRaises(TypeError, meth, ts, off42)\r
- self.assertRaises(TypeError, meth, ts, tzinfo=off42)\r
-\r
- def test_tzinfo_timetuple(self):\r
- # TestDateTime tested most of this. datetime adds a twist to the\r
- # DST flag.\r
- class DST(tzinfo):\r
- def __init__(self, dstvalue):\r
- if isinstance(dstvalue, int):\r
- dstvalue = timedelta(minutes=dstvalue)\r
- self.dstvalue = dstvalue\r
- def dst(self, dt):\r
- return self.dstvalue\r
-\r
- cls = self.theclass\r
- for dstvalue, flag in (-33, 1), (33, 1), (0, 0), (None, -1):\r
- d = cls(1, 1, 1, 10, 20, 30, 40, tzinfo=DST(dstvalue))\r
- t = d.timetuple()\r
- self.assertEqual(1, t.tm_year)\r
- self.assertEqual(1, t.tm_mon)\r
- self.assertEqual(1, t.tm_mday)\r
- self.assertEqual(10, t.tm_hour)\r
- self.assertEqual(20, t.tm_min)\r
- self.assertEqual(30, t.tm_sec)\r
- self.assertEqual(0, t.tm_wday)\r
- self.assertEqual(1, t.tm_yday)\r
- self.assertEqual(flag, t.tm_isdst)\r
-\r
- # dst() returns wrong type.\r
- self.assertRaises(TypeError, cls(1, 1, 1, tzinfo=DST("x")).timetuple)\r
-\r
- # dst() at the edge.\r
- self.assertEqual(cls(1,1,1, tzinfo=DST(1439)).timetuple().tm_isdst, 1)\r
- self.assertEqual(cls(1,1,1, tzinfo=DST(-1439)).timetuple().tm_isdst, 1)\r
-\r
- # dst() out of range.\r
- self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(1440)).timetuple)\r
- self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(-1440)).timetuple)\r
-\r
- def test_utctimetuple(self):\r
- class DST(tzinfo):\r
- def __init__(self, dstvalue):\r
- if isinstance(dstvalue, int):\r
- dstvalue = timedelta(minutes=dstvalue)\r
- self.dstvalue = dstvalue\r
- def dst(self, dt):\r
- return self.dstvalue\r
-\r
- cls = self.theclass\r
- # This can't work: DST didn't implement utcoffset.\r
- self.assertRaises(NotImplementedError,\r
- cls(1, 1, 1, tzinfo=DST(0)).utcoffset)\r
-\r
- class UOFS(DST):\r
- def __init__(self, uofs, dofs=None):\r
- DST.__init__(self, dofs)\r
- self.uofs = timedelta(minutes=uofs)\r
- def utcoffset(self, dt):\r
- return self.uofs\r
-\r
- # Ensure tm_isdst is 0 regardless of what dst() says: DST is never\r
- # in effect for a UTC time.\r
- for dstvalue in -33, 33, 0, None:\r
- d = cls(1, 2, 3, 10, 20, 30, 40, tzinfo=UOFS(-53, dstvalue))\r
- t = d.utctimetuple()\r
- self.assertEqual(d.year, t.tm_year)\r
- self.assertEqual(d.month, t.tm_mon)\r
- self.assertEqual(d.day, t.tm_mday)\r
- self.assertEqual(11, t.tm_hour) # 20mm + 53mm = 1hn + 13mm\r
- self.assertEqual(13, t.tm_min)\r
- self.assertEqual(d.second, t.tm_sec)\r
- self.assertEqual(d.weekday(), t.tm_wday)\r
- self.assertEqual(d.toordinal() - date(1, 1, 1).toordinal() + 1,\r
- t.tm_yday)\r
- self.assertEqual(0, t.tm_isdst)\r
-\r
- # At the edges, UTC adjustment can normalize into years out-of-range\r
- # for a datetime object. Ensure that a correct timetuple is\r
- # created anyway.\r
- tiny = cls(MINYEAR, 1, 1, 0, 0, 37, tzinfo=UOFS(1439))\r
- # That goes back 1 minute less than a full day.\r
- t = tiny.utctimetuple()\r
- self.assertEqual(t.tm_year, MINYEAR-1)\r
- self.assertEqual(t.tm_mon, 12)\r
- self.assertEqual(t.tm_mday, 31)\r
- self.assertEqual(t.tm_hour, 0)\r
- self.assertEqual(t.tm_min, 1)\r
- self.assertEqual(t.tm_sec, 37)\r
- self.assertEqual(t.tm_yday, 366) # "year 0" is a leap year\r
- self.assertEqual(t.tm_isdst, 0)\r
-\r
- huge = cls(MAXYEAR, 12, 31, 23, 59, 37, 999999, tzinfo=UOFS(-1439))\r
- # That goes forward 1 minute less than a full day.\r
- t = huge.utctimetuple()\r
- self.assertEqual(t.tm_year, MAXYEAR+1)\r
- self.assertEqual(t.tm_mon, 1)\r
- self.assertEqual(t.tm_mday, 1)\r
- self.assertEqual(t.tm_hour, 23)\r
- self.assertEqual(t.tm_min, 58)\r
- self.assertEqual(t.tm_sec, 37)\r
- self.assertEqual(t.tm_yday, 1)\r
- self.assertEqual(t.tm_isdst, 0)\r
-\r
- def test_tzinfo_isoformat(self):\r
- zero = FixedOffset(0, "+00:00")\r
- plus = FixedOffset(220, "+03:40")\r
- minus = FixedOffset(-231, "-03:51")\r
- unknown = FixedOffset(None, "")\r
-\r
- cls = self.theclass\r
- datestr = '0001-02-03'\r
- for ofs in None, zero, plus, minus, unknown:\r
- for us in 0, 987001:\r
- d = cls(1, 2, 3, 4, 5, 59, us, tzinfo=ofs)\r
- timestr = '04:05:59' + (us and '.987001' or '')\r
- ofsstr = ofs is not None and d.tzname() or ''\r
- tailstr = timestr + ofsstr\r
- iso = d.isoformat()\r
- self.assertEqual(iso, datestr + 'T' + tailstr)\r
- self.assertEqual(iso, d.isoformat('T'))\r
- self.assertEqual(d.isoformat('k'), datestr + 'k' + tailstr)\r
- self.assertEqual(str(d), datestr + ' ' + tailstr)\r
-\r
- def test_replace(self):\r
- cls = self.theclass\r
- z100 = FixedOffset(100, "+100")\r
- zm200 = FixedOffset(timedelta(minutes=-200), "-200")\r
- args = [1, 2, 3, 4, 5, 6, 7, z100]\r
- base = cls(*args)\r
- self.assertEqual(base, base.replace())\r
-\r
- i = 0\r
- for name, newval in (("year", 2),\r
- ("month", 3),\r
- ("day", 4),\r
- ("hour", 5),\r
- ("minute", 6),\r
- ("second", 7),\r
- ("microsecond", 8),\r
- ("tzinfo", zm200)):\r
- newargs = args[:]\r
- newargs[i] = newval\r
- expected = cls(*newargs)\r
- got = base.replace(**{name: newval})\r
- self.assertEqual(expected, got)\r
- i += 1\r
-\r
- # Ensure we can get rid of a tzinfo.\r
- self.assertEqual(base.tzname(), "+100")\r
- base2 = base.replace(tzinfo=None)\r
- self.assertTrue(base2.tzinfo is None)\r
- self.assertTrue(base2.tzname() is None)\r
-\r
- # Ensure we can add one.\r
- base3 = base2.replace(tzinfo=z100)\r
- self.assertEqual(base, base3)\r
- self.assertTrue(base.tzinfo is base3.tzinfo)\r
-\r
- # Out of bounds.\r
- base = cls(2000, 2, 29)\r
- self.assertRaises(ValueError, base.replace, year=2001)\r
-\r
- def test_more_astimezone(self):\r
- # The inherited test_astimezone covered some trivial and error cases.\r
- fnone = FixedOffset(None, "None")\r
- f44m = FixedOffset(44, "44")\r
- fm5h = FixedOffset(-timedelta(hours=5), "m300")\r
-\r
- dt = self.theclass.now(tz=f44m)\r
- self.assertTrue(dt.tzinfo is f44m)\r
- # Replacing with degenerate tzinfo raises an exception.\r
- self.assertRaises(ValueError, dt.astimezone, fnone)\r
- # Ditto with None tz.\r
- self.assertRaises(TypeError, dt.astimezone, None)\r
- # Replacing with same tzinfo makes no change.\r
- x = dt.astimezone(dt.tzinfo)\r
- self.assertTrue(x.tzinfo is f44m)\r
- self.assertEqual(x.date(), dt.date())\r
- self.assertEqual(x.time(), dt.time())\r
-\r
- # Replacing with different tzinfo does adjust.\r
- got = dt.astimezone(fm5h)\r
- self.assertTrue(got.tzinfo is fm5h)\r
- self.assertEqual(got.utcoffset(), timedelta(hours=-5))\r
- expected = dt - dt.utcoffset() # in effect, convert to UTC\r
- expected += fm5h.utcoffset(dt) # and from there to local time\r
- expected = expected.replace(tzinfo=fm5h) # and attach new tzinfo\r
- self.assertEqual(got.date(), expected.date())\r
- self.assertEqual(got.time(), expected.time())\r
- self.assertEqual(got.timetz(), expected.timetz())\r
- self.assertTrue(got.tzinfo is expected.tzinfo)\r
- self.assertEqual(got, expected)\r
-\r
- def test_aware_subtract(self):\r
- cls = self.theclass\r
-\r
- # Ensure that utcoffset() is ignored when the operands have the\r
- # same tzinfo member.\r
- class OperandDependentOffset(tzinfo):\r
- def utcoffset(self, t):\r
- if t.minute < 10:\r
- # d0 and d1 equal after adjustment\r
- return timedelta(minutes=t.minute)\r
- else:\r
- # d2 off in the weeds\r
- return timedelta(minutes=59)\r
-\r
- base = cls(8, 9, 10, 11, 12, 13, 14, tzinfo=OperandDependentOffset())\r
- d0 = base.replace(minute=3)\r
- d1 = base.replace(minute=9)\r
- d2 = base.replace(minute=11)\r
- for x in d0, d1, d2:\r
- for y in d0, d1, d2:\r
- got = x - y\r
- expected = timedelta(minutes=x.minute - y.minute)\r
- self.assertEqual(got, expected)\r
-\r
- # OTOH, if the tzinfo members are distinct, utcoffsets aren't\r
- # ignored.\r
- base = cls(8, 9, 10, 11, 12, 13, 14)\r
- d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())\r
- d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())\r
- d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())\r
- for x in d0, d1, d2:\r
- for y in d0, d1, d2:\r
- got = x - y\r
- if (x is d0 or x is d1) and (y is d0 or y is d1):\r
- expected = timedelta(0)\r
- elif x is y is d2:\r
- expected = timedelta(0)\r
- elif x is d2:\r
- expected = timedelta(minutes=(11-59)-0)\r
- else:\r
- assert y is d2\r
- expected = timedelta(minutes=0-(11-59))\r
- self.assertEqual(got, expected)\r
-\r
- def test_mixed_compare(self):\r
- t1 = datetime(1, 2, 3, 4, 5, 6, 7)\r
- t2 = datetime(1, 2, 3, 4, 5, 6, 7)\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=None)\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=FixedOffset(None, ""))\r
- self.assertEqual(t1, t2)\r
- t2 = t2.replace(tzinfo=FixedOffset(0, ""))\r
- self.assertRaises(TypeError, lambda: t1 == t2)\r
-\r
- # In datetime w/ identical tzinfo objects, utcoffset is ignored.\r
- class Varies(tzinfo):\r
- def __init__(self):\r
- self.offset = timedelta(minutes=22)\r
- def utcoffset(self, t):\r
- self.offset += timedelta(minutes=1)\r
- return self.offset\r
-\r
- v = Varies()\r
- t1 = t2.replace(tzinfo=v)\r
- t2 = t2.replace(tzinfo=v)\r
- self.assertEqual(t1.utcoffset(), timedelta(minutes=23))\r
- self.assertEqual(t2.utcoffset(), timedelta(minutes=24))\r
- self.assertEqual(t1, t2)\r
-\r
- # But if they're not identical, it isn't ignored.\r
- t2 = t2.replace(tzinfo=Varies())\r
- self.assertTrue(t1 < t2) # t1's offset counter still going up\r
-\r
- def test_subclass_datetimetz(self):\r
-\r
- class C(self.theclass):\r
- theAnswer = 42\r
-\r
- def __new__(cls, *args, **kws):\r
- temp = kws.copy()\r
- extra = temp.pop('extra')\r
- result = self.theclass.__new__(cls, *args, **temp)\r
- result.extra = extra\r
- return result\r
-\r
- def newmeth(self, start):\r
- return start + self.hour + self.year\r
-\r
- args = 2002, 12, 31, 4, 5, 6, 500, FixedOffset(-300, "EST", 1)\r
-\r
- dt1 = self.theclass(*args)\r
- dt2 = C(*args, **{'extra': 7})\r
-\r
- self.assertEqual(dt2.__class__, C)\r
- self.assertEqual(dt2.theAnswer, 42)\r
- self.assertEqual(dt2.extra, 7)\r
- self.assertEqual(dt1.utcoffset(), dt2.utcoffset())\r
- self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.year - 7)\r
-\r
-# Pain to set up DST-aware tzinfo classes.\r
-\r
-def first_sunday_on_or_after(dt):\r
- days_to_go = 6 - dt.weekday()\r
- if days_to_go:\r
- dt += timedelta(days_to_go)\r
- return dt\r
-\r
-ZERO = timedelta(0)\r
-HOUR = timedelta(hours=1)\r
-DAY = timedelta(days=1)\r
-# In the US, DST starts at 2am (standard time) on the first Sunday in April.\r
-DSTSTART = datetime(1, 4, 1, 2)\r
-# and ends at 2am (DST time; 1am standard time) on the last Sunday of Oct,\r
-# which is the first Sunday on or after Oct 25. Because we view 1:MM as\r
-# being standard time on that day, there is no spelling in local time of\r
-# the last hour of DST (that's 1:MM DST, but 1:MM is taken as standard time).\r
-DSTEND = datetime(1, 10, 25, 1)\r
-\r
-class USTimeZone(tzinfo):\r
-\r
- def __init__(self, hours, reprname, stdname, dstname):\r
- self.stdoffset = timedelta(hours=hours)\r
- self.reprname = reprname\r
- self.stdname = stdname\r
- self.dstname = dstname\r
-\r
- def __repr__(self):\r
- return self.reprname\r
-\r
- def tzname(self, dt):\r
- if self.dst(dt):\r
- return self.dstname\r
- else:\r
- return self.stdname\r
-\r
- def utcoffset(self, dt):\r
- return self.stdoffset + self.dst(dt)\r
-\r
- def dst(self, dt):\r
- if dt is None or dt.tzinfo is None:\r
- # An exception instead may be sensible here, in one or more of\r
- # the cases.\r
- return ZERO\r
- assert dt.tzinfo is self\r
-\r
- # Find first Sunday in April.\r
- start = first_sunday_on_or_after(DSTSTART.replace(year=dt.year))\r
- assert start.weekday() == 6 and start.month == 4 and start.day <= 7\r
-\r
- # Find last Sunday in October.\r
- end = first_sunday_on_or_after(DSTEND.replace(year=dt.year))\r
- assert end.weekday() == 6 and end.month == 10 and end.day >= 25\r
-\r
- # Can't compare naive to aware objects, so strip the timezone from\r
- # dt first.\r
- if start <= dt.replace(tzinfo=None) < end:\r
- return HOUR\r
- else:\r
- return ZERO\r
-\r
-Eastern = USTimeZone(-5, "Eastern", "EST", "EDT")\r
-Central = USTimeZone(-6, "Central", "CST", "CDT")\r
-Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")\r
-Pacific = USTimeZone(-8, "Pacific", "PST", "PDT")\r
-utc_real = FixedOffset(0, "UTC", 0)\r
-# For better test coverage, we want another flavor of UTC that's west of\r
-# the Eastern and Pacific timezones.\r
-utc_fake = FixedOffset(-12*60, "UTCfake", 0)\r
-\r
-class TestTimezoneConversions(unittest.TestCase):\r
- # The DST switch times for 2002, in std time.\r
- dston = datetime(2002, 4, 7, 2)\r
- dstoff = datetime(2002, 10, 27, 1)\r
-\r
- theclass = datetime\r
-\r
- # Check a time that's inside DST.\r
- def checkinside(self, dt, tz, utc, dston, dstoff):\r
- self.assertEqual(dt.dst(), HOUR)\r
-\r
- # Conversion to our own timezone is always an identity.\r
- self.assertEqual(dt.astimezone(tz), dt)\r
-\r
- asutc = dt.astimezone(utc)\r
- there_and_back = asutc.astimezone(tz)\r
-\r
- # Conversion to UTC and back isn't always an identity here,\r
- # because there are redundant spellings (in local time) of\r
- # UTC time when DST begins: the clock jumps from 1:59:59\r
- # to 3:00:00, and a local time of 2:MM:SS doesn't really\r
- # make sense then. The classes above treat 2:MM:SS as\r
- # daylight time then (it's "after 2am"), really an alias\r
- # for 1:MM:SS standard time. The latter form is what\r
- # conversion back from UTC produces.\r
- if dt.date() == dston.date() and dt.hour == 2:\r
- # We're in the redundant hour, and coming back from\r
- # UTC gives the 1:MM:SS standard-time spelling.\r
- self.assertEqual(there_and_back + HOUR, dt)\r
- # Although during was considered to be in daylight\r
- # time, there_and_back is not.\r
- self.assertEqual(there_and_back.dst(), ZERO)\r
- # They're the same times in UTC.\r
- self.assertEqual(there_and_back.astimezone(utc),\r
- dt.astimezone(utc))\r
- else:\r
- # We're not in the redundant hour.\r
- self.assertEqual(dt, there_and_back)\r
-\r
- # Because we have a redundant spelling when DST begins, there is\r
- # (unfortunately) an hour when DST ends that can't be spelled at all in\r
- # local time. When DST ends, the clock jumps from 1:59 back to 1:00\r
- # again. The hour 1:MM DST has no spelling then: 1:MM is taken to be\r
- # standard time. 1:MM DST == 0:MM EST, but 0:MM is taken to be\r
- # daylight time. The hour 1:MM daylight == 0:MM standard can't be\r
- # expressed in local time. Nevertheless, we want conversion back\r
- # from UTC to mimic the local clock's "repeat an hour" behavior.\r
- nexthour_utc = asutc + HOUR\r
- nexthour_tz = nexthour_utc.astimezone(tz)\r
- if dt.date() == dstoff.date() and dt.hour == 0:\r
- # We're in the hour before the last DST hour. The last DST hour\r
- # is ineffable. We want the conversion back to repeat 1:MM.\r
- self.assertEqual(nexthour_tz, dt.replace(hour=1))\r
- nexthour_utc += HOUR\r
- nexthour_tz = nexthour_utc.astimezone(tz)\r
- self.assertEqual(nexthour_tz, dt.replace(hour=1))\r
- else:\r
- self.assertEqual(nexthour_tz - dt, HOUR)\r
-\r
- # Check a time that's outside DST.\r
- def checkoutside(self, dt, tz, utc):\r
- self.assertEqual(dt.dst(), ZERO)\r
-\r
- # Conversion to our own timezone is always an identity.\r
- self.assertEqual(dt.astimezone(tz), dt)\r
-\r
- # Converting to UTC and back is an identity too.\r
- asutc = dt.astimezone(utc)\r
- there_and_back = asutc.astimezone(tz)\r
- self.assertEqual(dt, there_and_back)\r
-\r
- def convert_between_tz_and_utc(self, tz, utc):\r
- dston = self.dston.replace(tzinfo=tz)\r
- # Because 1:MM on the day DST ends is taken as being standard time,\r
- # there is no spelling in tz for the last hour of daylight time.\r
- # For purposes of the test, the last hour of DST is 0:MM, which is\r
- # taken as being daylight time (and 1:MM is taken as being standard\r
- # time).\r
- dstoff = self.dstoff.replace(tzinfo=tz)\r
- for delta in (timedelta(weeks=13),\r
- DAY,\r
- HOUR,\r
- timedelta(minutes=1),\r
- timedelta(microseconds=1)):\r
-\r
- self.checkinside(dston, tz, utc, dston, dstoff)\r
- for during in dston + delta, dstoff - delta:\r
- self.checkinside(during, tz, utc, dston, dstoff)\r
-\r
- self.checkoutside(dstoff, tz, utc)\r
- for outside in dston - delta, dstoff + delta:\r
- self.checkoutside(outside, tz, utc)\r
-\r
- def test_easy(self):\r
- # Despite the name of this test, the endcases are excruciating.\r
- self.convert_between_tz_and_utc(Eastern, utc_real)\r
- self.convert_between_tz_and_utc(Pacific, utc_real)\r
- self.convert_between_tz_and_utc(Eastern, utc_fake)\r
- self.convert_between_tz_and_utc(Pacific, utc_fake)\r
- # The next is really dancing near the edge. It works because\r
- # Pacific and Eastern are far enough apart that their "problem\r
- # hours" don't overlap.\r
- self.convert_between_tz_and_utc(Eastern, Pacific)\r
- self.convert_between_tz_and_utc(Pacific, Eastern)\r
- # OTOH, these fail! Don't enable them. The difficulty is that\r
- # the edge case tests assume that every hour is representable in\r
- # the "utc" class. This is always true for a fixed-offset tzinfo\r
- # class (lke utc_real and utc_fake), but not for Eastern or Central.\r
- # For these adjacent DST-aware time zones, the range of time offsets\r
- # tested ends up creating hours in the one that aren't representable\r
- # in the other. For the same reason, we would see failures in the\r
- # Eastern vs Pacific tests too if we added 3*HOUR to the list of\r
- # offset deltas in convert_between_tz_and_utc().\r
- #\r
- # self.convert_between_tz_and_utc(Eastern, Central) # can't work\r
- # self.convert_between_tz_and_utc(Central, Eastern) # can't work\r
-\r
- def test_tricky(self):\r
- # 22:00 on day before daylight starts.\r
- fourback = self.dston - timedelta(hours=4)\r
- ninewest = FixedOffset(-9*60, "-0900", 0)\r
- fourback = fourback.replace(tzinfo=ninewest)\r
- # 22:00-0900 is 7:00 UTC == 2:00 EST == 3:00 DST. Since it's "after\r
- # 2", we should get the 3 spelling.\r
- # If we plug 22:00 the day before into Eastern, it "looks like std\r
- # time", so its offset is returned as -5, and -5 - -9 = 4. Adding 4\r
- # to 22:00 lands on 2:00, which makes no sense in local time (the\r
- # local clock jumps from 1 to 3). The point here is to make sure we\r
- # get the 3 spelling.\r
- expected = self.dston.replace(hour=3)\r
- got = fourback.astimezone(Eastern).replace(tzinfo=None)\r
- self.assertEqual(expected, got)\r
-\r
- # Similar, but map to 6:00 UTC == 1:00 EST == 2:00 DST. In that\r
- # case we want the 1:00 spelling.\r
- sixutc = self.dston.replace(hour=6, tzinfo=utc_real)\r
- # Now 6:00 "looks like daylight", so the offset wrt Eastern is -4,\r
- # and adding -4-0 == -4 gives the 2:00 spelling. We want the 1:00 EST\r
- # spelling.\r
- expected = self.dston.replace(hour=1)\r
- got = sixutc.astimezone(Eastern).replace(tzinfo=None)\r
- self.assertEqual(expected, got)\r
-\r
- # Now on the day DST ends, we want "repeat an hour" behavior.\r
- # UTC 4:MM 5:MM 6:MM 7:MM checking these\r
- # EST 23:MM 0:MM 1:MM 2:MM\r
- # EDT 0:MM 1:MM 2:MM 3:MM\r
- # wall 0:MM 1:MM 1:MM 2:MM against these\r
- for utc in utc_real, utc_fake:\r
- for tz in Eastern, Pacific:\r
- first_std_hour = self.dstoff - timedelta(hours=2) # 23:MM\r
- # Convert that to UTC.\r
- first_std_hour -= tz.utcoffset(None)\r
- # Adjust for possibly fake UTC.\r
- asutc = first_std_hour + utc.utcoffset(None)\r
- # First UTC hour to convert; this is 4:00 when utc=utc_real &\r
- # tz=Eastern.\r
- asutcbase = asutc.replace(tzinfo=utc)\r
- for tzhour in (0, 1, 1, 2):\r
- expectedbase = self.dstoff.replace(hour=tzhour)\r
- for minute in 0, 30, 59:\r
- expected = expectedbase.replace(minute=minute)\r
- asutc = asutcbase.replace(minute=minute)\r
- astz = asutc.astimezone(tz)\r
- self.assertEqual(astz.replace(tzinfo=None), expected)\r
- asutcbase += HOUR\r
-\r
-\r
- def test_bogus_dst(self):\r
- class ok(tzinfo):\r
- def utcoffset(self, dt): return HOUR\r
- def dst(self, dt): return HOUR\r
-\r
- now = self.theclass.now().replace(tzinfo=utc_real)\r
- # Doesn't blow up.\r
- now.astimezone(ok())\r
-\r
- # Does blow up.\r
- class notok(ok):\r
- def dst(self, dt): return None\r
- self.assertRaises(ValueError, now.astimezone, notok())\r
-\r
- def test_fromutc(self):\r
- self.assertRaises(TypeError, Eastern.fromutc) # not enough args\r
- now = datetime.utcnow().replace(tzinfo=utc_real)\r
- self.assertRaises(ValueError, Eastern.fromutc, now) # wrong tzinfo\r
- now = now.replace(tzinfo=Eastern) # insert correct tzinfo\r
- enow = Eastern.fromutc(now) # doesn't blow up\r
- self.assertEqual(enow.tzinfo, Eastern) # has right tzinfo member\r
- self.assertRaises(TypeError, Eastern.fromutc, now, now) # too many args\r
- self.assertRaises(TypeError, Eastern.fromutc, date.today()) # wrong type\r
-\r
- # Always converts UTC to standard time.\r
- class FauxUSTimeZone(USTimeZone):\r
- def fromutc(self, dt):\r
- return dt + self.stdoffset\r
- FEastern = FauxUSTimeZone(-5, "FEastern", "FEST", "FEDT")\r
-\r
- # UTC 4:MM 5:MM 6:MM 7:MM 8:MM 9:MM\r
- # EST 23:MM 0:MM 1:MM 2:MM 3:MM 4:MM\r
- # EDT 0:MM 1:MM 2:MM 3:MM 4:MM 5:MM\r
-\r
- # Check around DST start.\r
- start = self.dston.replace(hour=4, tzinfo=Eastern)\r
- fstart = start.replace(tzinfo=FEastern)\r
- for wall in 23, 0, 1, 3, 4, 5:\r
- expected = start.replace(hour=wall)\r
- if wall == 23:\r
- expected -= timedelta(days=1)\r
- got = Eastern.fromutc(start)\r
- self.assertEqual(expected, got)\r
-\r
- expected = fstart + FEastern.stdoffset\r
- got = FEastern.fromutc(fstart)\r
- self.assertEqual(expected, got)\r
-\r
- # Ensure astimezone() calls fromutc() too.\r
- got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)\r
- self.assertEqual(expected, got)\r
-\r
- start += HOUR\r
- fstart += HOUR\r
-\r
- # Check around DST end.\r
- start = self.dstoff.replace(hour=4, tzinfo=Eastern)\r
- fstart = start.replace(tzinfo=FEastern)\r
- for wall in 0, 1, 1, 2, 3, 4:\r
- expected = start.replace(hour=wall)\r
- got = Eastern.fromutc(start)\r
- self.assertEqual(expected, got)\r
-\r
- expected = fstart + FEastern.stdoffset\r
- got = FEastern.fromutc(fstart)\r
- self.assertEqual(expected, got)\r
-\r
- # Ensure astimezone() calls fromutc() too.\r
- got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)\r
- self.assertEqual(expected, got)\r
-\r
- start += HOUR\r
- fstart += HOUR\r
-\r
-\r
-#############################################################################\r
-# oddballs\r
-\r
-class Oddballs(unittest.TestCase):\r
-\r
- def test_bug_1028306(self):\r
- # Trying to compare a date to a datetime should act like a mixed-\r
- # type comparison, despite that datetime is a subclass of date.\r
- as_date = date.today()\r
- as_datetime = datetime.combine(as_date, time())\r
- self.assertTrue(as_date != as_datetime)\r
- self.assertTrue(as_datetime != as_date)\r
- self.assertTrue(not as_date == as_datetime)\r
- self.assertTrue(not as_datetime == as_date)\r
- self.assertRaises(TypeError, lambda: as_date < as_datetime)\r
- self.assertRaises(TypeError, lambda: as_datetime < as_date)\r
- self.assertRaises(TypeError, lambda: as_date <= as_datetime)\r
- self.assertRaises(TypeError, lambda: as_datetime <= as_date)\r
- self.assertRaises(TypeError, lambda: as_date > as_datetime)\r
- self.assertRaises(TypeError, lambda: as_datetime > as_date)\r
- self.assertRaises(TypeError, lambda: as_date >= as_datetime)\r
- self.assertRaises(TypeError, lambda: as_datetime >= as_date)\r
-\r
- # Neverthelss, comparison should work with the base-class (date)\r
- # projection if use of a date method is forced.\r
- self.assertTrue(as_date.__eq__(as_datetime))\r
- different_day = (as_date.day + 1) % 20 + 1\r
- self.assertTrue(not as_date.__eq__(as_datetime.replace(day=\r
- different_day)))\r
-\r
- # And date should compare with other subclasses of date. If a\r
- # subclass wants to stop this, it's up to the subclass to do so.\r
- date_sc = SubclassDate(as_date.year, as_date.month, as_date.day)\r
- self.assertEqual(as_date, date_sc)\r
- self.assertEqual(date_sc, as_date)\r
-\r
- # Ditto for datetimes.\r
- datetime_sc = SubclassDatetime(as_datetime.year, as_datetime.month,\r
- as_date.day, 0, 0, 0)\r
- self.assertEqual(as_datetime, datetime_sc)\r
- self.assertEqual(datetime_sc, as_datetime)\r
-\r
-def test_main():\r
- test_support.run_unittest(__name__)\r
-\r
-if __name__ == "__main__":\r
- test_main()\r
projects / mirror_edk2.git / blobdiff