?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix to work on python <= 2.1
[python/dscho.git] / Lib / test / test_datetime.py
blobc6dbb4895624f3451002b9dfb2bd7210a08122be
1 """Test date/time type.
2
3 See http://www.zope.org/Members/fdrake/DateTimeWiki/TestCases
4 """
5
6 import sys
7 import pickle
8 import cPickle
9 import unittest
10
11 from test import test_support
12
13 from datetime import MINYEAR, MAXYEAR
14 from datetime import timedelta
15 from datetime import tzinfo
16 from datetime import time
17 from datetime import date, datetime
18
19 pickle_choices = [(pickler, unpickler, proto)
20 for pickler in pickle, cPickle
21 for unpickler in pickle, cPickle
22 for proto in range(3)]
23 assert len(pickle_choices) == 2*2*3
24
25 # An arbitrary collection of objects of non-datetime types, for testing
26 # mixed-type comparisons.
27 OTHERSTUFF = (10, 10L, 34.5, "abc", {}, [], ())
28
29
30 #############################################################################
31 # module tests
32
33 class TestModule(unittest.TestCase):
34
35 def test_constants(self):
36 import datetime
37 self.assertEqual(datetime.MINYEAR, 1)
38 self.assertEqual(datetime.MAXYEAR, 9999)
39
40 #############################################################################
41 # tzinfo tests
42
43 class FixedOffset(tzinfo):
44 def __init__(self, offset, name, dstoffset=42):
45 if isinstance(offset, int):
46 offset = timedelta(minutes=offset)
47 if isinstance(dstoffset, int):
48 dstoffset = timedelta(minutes=dstoffset)
49 self.__offset = offset
50 self.__name = name
51 self.__dstoffset = dstoffset
52 def __repr__(self):
53 return self.__name.lower()
54 def utcoffset(self, dt):
55 return self.__offset
56 def tzname(self, dt):
57 return self.__name
58 def dst(self, dt):
59 return self.__dstoffset
60
61 class PicklableFixedOffset(FixedOffset):
62 def __init__(self, offset=None, name=None, dstoffset=None):
63 FixedOffset.__init__(self, offset, name, dstoffset)
64
65 class TestTZInfo(unittest.TestCase):
66
67 def test_non_abstractness(self):
68 # In order to allow subclasses to get pickled, the C implementation
69 # wasn't able to get away with having __init__ raise
70 # NotImplementedError.
71 useless = tzinfo()
72 dt = datetime.max
73 self.assertRaises(NotImplementedError, useless.tzname, dt)
74 self.assertRaises(NotImplementedError, useless.utcoffset, dt)
75 self.assertRaises(NotImplementedError, useless.dst, dt)
76
77 def test_subclass_must_override(self):
78 class NotEnough(tzinfo):
79 def __init__(self, offset, name):
80 self.__offset = offset
81 self.__name = name
82 self.failUnless(issubclass(NotEnough, tzinfo))
83 ne = NotEnough(3, "NotByALongShot")
84 self.failUnless(isinstance(ne, tzinfo))
85
86 dt = datetime.now()
87 self.assertRaises(NotImplementedError, ne.tzname, dt)
88 self.assertRaises(NotImplementedError, ne.utcoffset, dt)
89 self.assertRaises(NotImplementedError, ne.dst, dt)
90
91 def test_normal(self):
92 fo = FixedOffset(3, "Three")
93 self.failUnless(isinstance(fo, tzinfo))
94 for dt in datetime.now(), None:
95 self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))
96 self.assertEqual(fo.tzname(dt), "Three")
97 self.assertEqual(fo.dst(dt), timedelta(minutes=42))
98
99 def test_pickling_base(self):
100 # There's no point to pickling tzinfo objects on their own (they
101 # carry no data), but they need to be picklable anyway else
102 # concrete subclasses can't be pickled.
103 orig = tzinfo.__new__(tzinfo)
104 self.failUnless(type(orig) is tzinfo)
105 for pickler, unpickler, proto in pickle_choices:
106 green = pickler.dumps(orig, proto)
107 derived = unpickler.loads(green)
108 self.failUnless(type(derived) is tzinfo)
109
110 def test_pickling_subclass(self):
111 # Make sure we can pickle/unpickle an instance of a subclass.
112 offset = timedelta(minutes=-300)
113 orig = PicklableFixedOffset(offset, 'cookie')
114 self.failUnless(isinstance(orig, tzinfo))
115 self.failUnless(type(orig) is PicklableFixedOffset)
116 self.assertEqual(orig.utcoffset(None), offset)
117 self.assertEqual(orig.tzname(None), 'cookie')
118 for pickler, unpickler, proto in pickle_choices:
119 green = pickler.dumps(orig, proto)
120 derived = unpickler.loads(green)
121 self.failUnless(isinstance(derived, tzinfo))
122 self.failUnless(type(derived) is PicklableFixedOffset)
123 self.assertEqual(derived.utcoffset(None), offset)
124 self.assertEqual(derived.tzname(None), 'cookie')
125
126 #############################################################################
127 # Base clase for testing a particular aspect of timedelta, time, date and
128 # datetime comparisons.
129
130 class HarmlessMixedComparison(unittest.TestCase):
131 # Test that __eq__ and __ne__ don't complain for mixed-type comparisons.
132
133 # Subclasses must define 'theclass', and theclass(1, 1, 1) must be a
134 # legit constructor.
135
136 def test_harmless_mixed_comparison(self):
137 me = self.theclass(1, 1, 1)
138
139 self.failIf(me == ())
140 self.failUnless(me != ())
141 self.failIf(() == me)
142 self.failUnless(() != me)
143
144 self.failUnless(me in [1, 20L, [], me])
145 self.failIf(me not in [1, 20L, [], me])
146
147 self.failUnless([] in [me, 1, 20L, []])
148 self.failIf([] not in [me, 1, 20L, []])
149
150 def test_harmful_mixed_comparison(self):
151 me = self.theclass(1, 1, 1)
152
153 self.assertRaises(TypeError, lambda: me < ())
154 self.assertRaises(TypeError, lambda: me <= ())
155 self.assertRaises(TypeError, lambda: me > ())
156 self.assertRaises(TypeError, lambda: me >= ())
157
158 self.assertRaises(TypeError, lambda: () < me)
159 self.assertRaises(TypeError, lambda: () <= me)
160 self.assertRaises(TypeError, lambda: () > me)
161 self.assertRaises(TypeError, lambda: () >= me)
162
163 self.assertRaises(TypeError, cmp, (), me)
164 self.assertRaises(TypeError, cmp, me, ())
165
166 #############################################################################
167 # timedelta tests
168
169 class TestTimeDelta(HarmlessMixedComparison):
170
171 theclass = timedelta
172
173 def test_constructor(self):
174 eq = self.assertEqual
175 td = timedelta
176
177 # Check keyword args to constructor
178 eq(td(), td(weeks=0, days=0, hours=0, minutes=0, seconds=0,
179 milliseconds=0, microseconds=0))
180 eq(td(1), td(days=1))
181 eq(td(0, 1), td(seconds=1))
182 eq(td(0, 0, 1), td(microseconds=1))
183 eq(td(weeks=1), td(days=7))
184 eq(td(days=1), td(hours=24))
185 eq(td(hours=1), td(minutes=60))
186 eq(td(minutes=1), td(seconds=60))
187 eq(td(seconds=1), td(milliseconds=1000))
188 eq(td(milliseconds=1), td(microseconds=1000))
189
190 # Check float args to constructor
191 eq(td(weeks=1.0/7), td(days=1))
192 eq(td(days=1.0/24), td(hours=1))
193 eq(td(hours=1.0/60), td(minutes=1))
194 eq(td(minutes=1.0/60), td(seconds=1))
195 eq(td(seconds=0.001), td(milliseconds=1))
196 eq(td(milliseconds=0.001), td(microseconds=1))
197
198 def test_computations(self):
199 eq = self.assertEqual
200 td = timedelta
201
202 a = td(7) # One week
203 b = td(0, 60) # One minute
204 c = td(0, 0, 1000) # One millisecond
205 eq(a+b+c, td(7, 60, 1000))
206 eq(a-b, td(6, 24*3600 - 60))
207 eq(-a, td(-7))
208 eq(+a, td(7))
209 eq(-b, td(-1, 24*3600 - 60))
210 eq(-c, td(-1, 24*3600 - 1, 999000))
211 eq(abs(a), a)
212 eq(abs(-a), a)
213 eq(td(6, 24*3600), a)
214 eq(td(0, 0, 60*1000000), b)
215 eq(a*10, td(70))
216 eq(a*10, 10*a)
217 eq(a*10L, 10*a)
218 eq(b*10, td(0, 600))
219 eq(10*b, td(0, 600))
220 eq(b*10L, td(0, 600))
221 eq(c*10, td(0, 0, 10000))
222 eq(10*c, td(0, 0, 10000))
223 eq(c*10L, td(0, 0, 10000))
224 eq(a*-1, -a)
225 eq(b*-2, -b-b)
226 eq(c*-2, -c+-c)
227 eq(b*(60*24), (b*60)*24)
228 eq(b*(60*24), (60*b)*24)
229 eq(c*1000, td(0, 1))
230 eq(1000*c, td(0, 1))
231 eq(a//7, td(1))
232 eq(b//10, td(0, 6))
233 eq(c//1000, td(0, 0, 1))
234 eq(a//10, td(0, 7*24*360))
235 eq(a//3600000, td(0, 0, 7*24*1000))
236
237 def test_disallowed_computations(self):
238 a = timedelta(42)
239
240 # Add/sub ints, longs, floats should be illegal
241 for i in 1, 1L, 1.0:
242 self.assertRaises(TypeError, lambda: a+i)
243 self.assertRaises(TypeError, lambda: a-i)
244 self.assertRaises(TypeError, lambda: i+a)
245 self.assertRaises(TypeError, lambda: i-a)
246
247 # Mul/div by float isn't supported.
248 x = 2.3
249 self.assertRaises(TypeError, lambda: a*x)
250 self.assertRaises(TypeError, lambda: x*a)
251 self.assertRaises(TypeError, lambda: a/x)
252 self.assertRaises(TypeError, lambda: x/a)
253 self.assertRaises(TypeError, lambda: a // x)
254 self.assertRaises(TypeError, lambda: x // a)
255
256 # Divison of int by timedelta doesn't make sense.
257 # Division by zero doesn't make sense.
258 for zero in 0, 0L:
259 self.assertRaises(TypeError, lambda: zero // a)
260 self.assertRaises(ZeroDivisionError, lambda: a // zero)
261
262 def test_basic_attributes(self):
263 days, seconds, us = 1, 7, 31
264 td = timedelta(days, seconds, us)
265 self.assertEqual(td.days, days)
266 self.assertEqual(td.seconds, seconds)
267 self.assertEqual(td.microseconds, us)
268
269 def test_carries(self):
270 t1 = timedelta(days=100,
271 weeks=-7,
272 hours=-24*(100-49),
273 minutes=-3,
274 seconds=12,
275 microseconds=(3*60 - 12) * 1e6 + 1)
276 t2 = timedelta(microseconds=1)
277 self.assertEqual(t1, t2)
278
279 def test_hash_equality(self):
280 t1 = timedelta(days=100,
281 weeks=-7,
282 hours=-24*(100-49),
283 minutes=-3,
284 seconds=12,
285 microseconds=(3*60 - 12) * 1000000)
286 t2 = timedelta()
287 self.assertEqual(hash(t1), hash(t2))
288
289 t1 += timedelta(weeks=7)
290 t2 += timedelta(days=7*7)
291 self.assertEqual(t1, t2)
292 self.assertEqual(hash(t1), hash(t2))
293
294 d = {t1: 1}
295 d[t2] = 2
296 self.assertEqual(len(d), 1)
297 self.assertEqual(d[t1], 2)
298
299 def test_pickling(self):
300 args = 12, 34, 56
301 orig = timedelta(*args)
302 for pickler, unpickler, proto in pickle_choices:
303 green = pickler.dumps(orig, proto)
304 derived = unpickler.loads(green)
305 self.assertEqual(orig, derived)
306
307 def test_compare(self):
308 t1 = timedelta(2, 3, 4)
309 t2 = timedelta(2, 3, 4)
310 self.failUnless(t1 == t2)
311 self.failUnless(t1 <= t2)
312 self.failUnless(t1 >= t2)
313 self.failUnless(not t1 != t2)
314 self.failUnless(not t1 < t2)
315 self.failUnless(not t1 > t2)
316 self.assertEqual(cmp(t1, t2), 0)
317 self.assertEqual(cmp(t2, t1), 0)
318
319 for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
320 t2 = timedelta(*args) # this is larger than t1
321 self.failUnless(t1 < t2)
322 self.failUnless(t2 > t1)
323 self.failUnless(t1 <= t2)
324 self.failUnless(t2 >= t1)
325 self.failUnless(t1 != t2)
326 self.failUnless(t2 != t1)
327 self.failUnless(not t1 == t2)
328 self.failUnless(not t2 == t1)
329 self.failUnless(not t1 > t2)
330 self.failUnless(not t2 < t1)
331 self.failUnless(not t1 >= t2)
332 self.failUnless(not t2 <= t1)
333 self.assertEqual(cmp(t1, t2), -1)
334 self.assertEqual(cmp(t2, t1), 1)
335
336 for badarg in OTHERSTUFF:
337 self.assertEqual(t1 == badarg, False)
338 self.assertEqual(t1 != badarg, True)
339 self.assertEqual(badarg == t1, False)
340 self.assertEqual(badarg != t1, True)
341
342 self.assertRaises(TypeError, lambda: t1 <= badarg)
343 self.assertRaises(TypeError, lambda: t1 < badarg)
344 self.assertRaises(TypeError, lambda: t1 > badarg)
345 self.assertRaises(TypeError, lambda: t1 >= badarg)
346 self.assertRaises(TypeError, lambda: badarg <= t1)
347 self.assertRaises(TypeError, lambda: badarg < t1)
348 self.assertRaises(TypeError, lambda: badarg > t1)
349 self.assertRaises(TypeError, lambda: badarg >= t1)
350
351 def test_str(self):
352 td = timedelta
353 eq = self.assertEqual
354
355 eq(str(td(1)), "1 day, 0:00:00")
356 eq(str(td(-1)), "-1 day, 0:00:00")
357 eq(str(td(2)), "2 days, 0:00:00")
358 eq(str(td(-2)), "-2 days, 0:00:00")
359
360 eq(str(td(hours=12, minutes=58, seconds=59)), "12:58:59")
361 eq(str(td(hours=2, minutes=3, seconds=4)), "2:03:04")
362 eq(str(td(weeks=-30, hours=23, minutes=12, seconds=34)),
363 "-210 days, 23:12:34")
364
365 eq(str(td(milliseconds=1)), "0:00:00.001000")
366 eq(str(td(microseconds=3)), "0:00:00.000003")
367
368 eq(str(td(days=999999999, hours=23, minutes=59, seconds=59,
369 microseconds=999999)),
370 "999999999 days, 23:59:59.999999")
371
372 def test_roundtrip(self):
373 for td in (timedelta(days=999999999, hours=23, minutes=59,
374 seconds=59, microseconds=999999),
375 timedelta(days=-999999999),
376 timedelta(days=1, seconds=2, microseconds=3)):
377
378 # Verify td -> string -> td identity.
379 s = repr(td)
380 self.failUnless(s.startswith('datetime.'))
381 s = s[9:]
382 td2 = eval(s)
383 self.assertEqual(td, td2)
384
385 # Verify identity via reconstructing from pieces.
386 td2 = timedelta(td.days, td.seconds, td.microseconds)
387 self.assertEqual(td, td2)
388
389 def test_resolution_info(self):
390 self.assert_(isinstance(timedelta.min, timedelta))
391 self.assert_(isinstance(timedelta.max, timedelta))
392 self.assert_(isinstance(timedelta.resolution, timedelta))
393 self.assert_(timedelta.max > timedelta.min)
394 self.assertEqual(timedelta.min, timedelta(-999999999))
395 self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))
396 self.assertEqual(timedelta.resolution, timedelta(0, 0, 1))
397
398 def test_overflow(self):
399 tiny = timedelta.resolution
400
401 td = timedelta.min + tiny
402 td -= tiny # no problem
403 self.assertRaises(OverflowError, td.__sub__, tiny)
404 self.assertRaises(OverflowError, td.__add__, -tiny)
405
406 td = timedelta.max - tiny
407 td += tiny # no problem
408 self.assertRaises(OverflowError, td.__add__, tiny)
409 self.assertRaises(OverflowError, td.__sub__, -tiny)
410
411 self.assertRaises(OverflowError, lambda: -timedelta.max)
412
413 def test_microsecond_rounding(self):
414 td = timedelta
415 eq = self.assertEqual
416
417 # Single-field rounding.
418 eq(td(milliseconds=0.4/1000), td(0)) # rounds to 0
419 eq(td(milliseconds=-0.4/1000), td(0)) # rounds to 0
420 eq(td(milliseconds=0.6/1000), td(microseconds=1))
421 eq(td(milliseconds=-0.6/1000), td(microseconds=-1))
422
423 # Rounding due to contributions from more than one field.
424 us_per_hour = 3600e6
425 us_per_day = us_per_hour * 24
426 eq(td(days=.4/us_per_day), td(0))
427 eq(td(hours=.2/us_per_hour), td(0))
428 eq(td(days=.4/us_per_day, hours=.2/us_per_hour), td(microseconds=1))
429
430 eq(td(days=-.4/us_per_day), td(0))
431 eq(td(hours=-.2/us_per_hour), td(0))
432 eq(td(days=-.4/us_per_day, hours=-.2/us_per_hour), td(microseconds=-1))
433
434 def test_massive_normalization(self):
435 td = timedelta(microseconds=-1)
436 self.assertEqual((td.days, td.seconds, td.microseconds),
437 (-1, 24*3600-1, 999999))
438
439 def test_bool(self):
440 self.failUnless(timedelta(1))
441 self.failUnless(timedelta(0, 1))
442 self.failUnless(timedelta(0, 0, 1))
443 self.failUnless(timedelta(microseconds=1))
444 self.failUnless(not timedelta(0))
445
446 def test_subclass_timedelta(self):
447
448 class T(timedelta):
449 def from_td(td):
450 return T(td.days, td.seconds, td.microseconds)
451 from_td = staticmethod(from_td)
452
453 def as_hours(self):
454 sum = (self.days * 24 +
455 self.seconds / 3600.0 +
456 self.microseconds / 3600e6)
457 return round(sum)
458
459 t1 = T(days=1)
460 self.assert_(type(t1) is T)
461 self.assertEqual(t1.as_hours(), 24)
462
463 t2 = T(days=-1, seconds=-3600)
464 self.assert_(type(t2) is T)
465 self.assertEqual(t2.as_hours(), -25)
466
467 t3 = t1 + t2
468 self.assert_(type(t3) is timedelta)
469 t4 = T.from_td(t3)
470 self.assert_(type(t4) is T)
471 self.assertEqual(t3.days, t4.days)
472 self.assertEqual(t3.seconds, t4.seconds)
473 self.assertEqual(t3.microseconds, t4.microseconds)
474 self.assertEqual(str(t3), str(t4))
475 self.assertEqual(t4.as_hours(), -1)
476
477 #############################################################################
478 # date tests
479
480 class TestDateOnly(unittest.TestCase):
481 # Tests here won't pass if also run on datetime objects, so don't
482 # subclass this to test datetimes too.
483
484 def test_delta_non_days_ignored(self):
485 dt = date(2000, 1, 2)
486 delta = timedelta(days=1, hours=2, minutes=3, seconds=4,
487 microseconds=5)
488 days = timedelta(delta.days)
489 self.assertEqual(days, timedelta(1))
490
491 dt2 = dt + delta
492 self.assertEqual(dt2, dt + days)
493
494 dt2 = delta + dt
495 self.assertEqual(dt2, dt + days)
496
497 dt2 = dt - delta
498 self.assertEqual(dt2, dt - days)
499
500 delta = -delta
501 days = timedelta(delta.days)
502 self.assertEqual(days, timedelta(-2))
503
504 dt2 = dt + delta
505 self.assertEqual(dt2, dt + days)
506
507 dt2 = delta + dt
508 self.assertEqual(dt2, dt + days)
509
510 dt2 = dt - delta
511 self.assertEqual(dt2, dt - days)
512
513 class TestDate(HarmlessMixedComparison):
514 # Tests here should pass for both dates and datetimes, except for a
515 # few tests that TestDateTime overrides.
516
517 theclass = date
518
519 def test_basic_attributes(self):
520 dt = self.theclass(2002, 3, 1)
521 self.assertEqual(dt.year, 2002)
522 self.assertEqual(dt.month, 3)
523 self.assertEqual(dt.day, 1)
524
525 def test_roundtrip(self):
526 for dt in (self.theclass(1, 2, 3),
527 self.theclass.today()):
528 # Verify dt -> string -> date identity.
529 s = repr(dt)
530 self.failUnless(s.startswith('datetime.'))
531 s = s[9:]
532 dt2 = eval(s)
533 self.assertEqual(dt, dt2)
534
535 # Verify identity via reconstructing from pieces.
536 dt2 = self.theclass(dt.year, dt.month, dt.day)
537 self.assertEqual(dt, dt2)
538
539 def test_ordinal_conversions(self):
540 # Check some fixed values.
541 for y, m, d, n in [(1, 1, 1, 1), # calendar origin
542 (1, 12, 31, 365),
543 (2, 1, 1, 366),
544 # first example from "Calendrical Calculations"
545 (1945, 11, 12, 710347)]:
546 d = self.theclass(y, m, d)
547 self.assertEqual(n, d.toordinal())
548 fromord = self.theclass.fromordinal(n)
549 self.assertEqual(d, fromord)
550 if hasattr(fromord, "hour"):
551 # if we're checking something fancier than a date, verify
552 # the extra fields have been zeroed out
553 self.assertEqual(fromord.hour, 0)
554 self.assertEqual(fromord.minute, 0)
555 self.assertEqual(fromord.second, 0)
556 self.assertEqual(fromord.microsecond, 0)
557
558 # Check first and last days of year spottily across the whole
559 # range of years supported.
560 for year in xrange(MINYEAR, MAXYEAR+1, 7):
561 # Verify (year, 1, 1) -> ordinal -> y, m, d is identity.
562 d = self.theclass(year, 1, 1)
563 n = d.toordinal()
564 d2 = self.theclass.fromordinal(n)
565 self.assertEqual(d, d2)
566 # Verify that moving back a day gets to the end of year-1.
567 if year > 1:
568 d = self.theclass.fromordinal(n-1)
569 d2 = self.theclass(year-1, 12, 31)
570 self.assertEqual(d, d2)
571 self.assertEqual(d2.toordinal(), n-1)
572
573 # Test every day in a leap-year and a non-leap year.
574 dim = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
575 for year, isleap in (2000, True), (2002, False):
576 n = self.theclass(year, 1, 1).toordinal()
577 for month, maxday in zip(range(1, 13), dim):
578 if month == 2 and isleap:
579 maxday += 1
580 for day in range(1, maxday+1):
581 d = self.theclass(year, month, day)
582 self.assertEqual(d.toordinal(), n)
583 self.assertEqual(d, self.theclass.fromordinal(n))
584 n += 1
585
586 def test_extreme_ordinals(self):
587 a = self.theclass.min
588 a = self.theclass(a.year, a.month, a.day) # get rid of time parts
589 aord = a.toordinal()
590 b = a.fromordinal(aord)
591 self.assertEqual(a, b)
592
593 self.assertRaises(ValueError, lambda: a.fromordinal(aord - 1))
594
595 b = a + timedelta(days=1)
596 self.assertEqual(b.toordinal(), aord + 1)
597 self.assertEqual(b, self.theclass.fromordinal(aord + 1))
598
599 a = self.theclass.max
600 a = self.theclass(a.year, a.month, a.day) # get rid of time parts
601 aord = a.toordinal()
602 b = a.fromordinal(aord)
603 self.assertEqual(a, b)
604
605 self.assertRaises(ValueError, lambda: a.fromordinal(aord + 1))
606
607 b = a - timedelta(days=1)
608 self.assertEqual(b.toordinal(), aord - 1)
609 self.assertEqual(b, self.theclass.fromordinal(aord - 1))
610
611 def test_bad_constructor_arguments(self):
612 # bad years
613 self.theclass(MINYEAR, 1, 1) # no exception
614 self.theclass(MAXYEAR, 1, 1) # no exception
615 self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)
616 self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)
617 # bad months
618 self.theclass(2000, 1, 1) # no exception
619 self.theclass(2000, 12, 1) # no exception
620 self.assertRaises(ValueError, self.theclass, 2000, 0, 1)
621 self.assertRaises(ValueError, self.theclass, 2000, 13, 1)
622 # bad days
623 self.theclass(2000, 2, 29) # no exception
624 self.theclass(2004, 2, 29) # no exception
625 self.theclass(2400, 2, 29) # no exception
626 self.assertRaises(ValueError, self.theclass, 2000, 2, 30)
627 self.assertRaises(ValueError, self.theclass, 2001, 2, 29)
628 self.assertRaises(ValueError, self.theclass, 2100, 2, 29)
629 self.assertRaises(ValueError, self.theclass, 1900, 2, 29)
630 self.assertRaises(ValueError, self.theclass, 2000, 1, 0)
631 self.assertRaises(ValueError, self.theclass, 2000, 1, 32)
632
633 def test_hash_equality(self):
634 d = self.theclass(2000, 12, 31)
635 # same thing
636 e = self.theclass(2000, 12, 31)
637 self.assertEqual(d, e)
638 self.assertEqual(hash(d), hash(e))
639
640 dic = {d: 1}
641 dic[e] = 2
642 self.assertEqual(len(dic), 1)
643 self.assertEqual(dic[d], 2)
644 self.assertEqual(dic[e], 2)
645
646 d = self.theclass(2001, 1, 1)
647 # same thing
648 e = self.theclass(2001, 1, 1)
649 self.assertEqual(d, e)
650 self.assertEqual(hash(d), hash(e))
651
652 dic = {d: 1}
653 dic[e] = 2
654 self.assertEqual(len(dic), 1)
655 self.assertEqual(dic[d], 2)
656 self.assertEqual(dic[e], 2)
657
658 def test_computations(self):
659 a = self.theclass(2002, 1, 31)
660 b = self.theclass(1956, 1, 31)
661
662 diff = a-b
663 self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))
664 self.assertEqual(diff.seconds, 0)
665 self.assertEqual(diff.microseconds, 0)
666
667 day = timedelta(1)
668 week = timedelta(7)
669 a = self.theclass(2002, 3, 2)
670 self.assertEqual(a + day, self.theclass(2002, 3, 3))
671 self.assertEqual(day + a, self.theclass(2002, 3, 3))
672 self.assertEqual(a - day, self.theclass(2002, 3, 1))
673 self.assertEqual(-day + a, self.theclass(2002, 3, 1))
674 self.assertEqual(a + week, self.theclass(2002, 3, 9))
675 self.assertEqual(a - week, self.theclass(2002, 2, 23))
676 self.assertEqual(a + 52*week, self.theclass(2003, 3, 1))
677 self.assertEqual(a - 52*week, self.theclass(2001, 3, 3))
678 self.assertEqual((a + week) - a, week)
679 self.assertEqual((a + day) - a, day)
680 self.assertEqual((a - week) - a, -week)
681 self.assertEqual((a - day) - a, -day)
682 self.assertEqual(a - (a + week), -week)
683 self.assertEqual(a - (a + day), -day)
684 self.assertEqual(a - (a - week), week)
685 self.assertEqual(a - (a - day), day)
686
687 # Add/sub ints, longs, floats should be illegal
688 for i in 1, 1L, 1.0:
689 self.assertRaises(TypeError, lambda: a+i)
690 self.assertRaises(TypeError, lambda: a-i)
691 self.assertRaises(TypeError, lambda: i+a)
692 self.assertRaises(TypeError, lambda: i-a)
693
694 # delta - date is senseless.
695 self.assertRaises(TypeError, lambda: day - a)
696 # mixing date and (delta or date) via * or // is senseless
697 self.assertRaises(TypeError, lambda: day * a)
698 self.assertRaises(TypeError, lambda: a * day)
699 self.assertRaises(TypeError, lambda: day // a)
700 self.assertRaises(TypeError, lambda: a // day)
701 self.assertRaises(TypeError, lambda: a * a)
702 self.assertRaises(TypeError, lambda: a // a)
703 # date + date is senseless
704 self.assertRaises(TypeError, lambda: a + a)
705
706 def test_overflow(self):
707 tiny = self.theclass.resolution
708
709 dt = self.theclass.min + tiny
710 dt -= tiny # no problem
711 self.assertRaises(OverflowError, dt.__sub__, tiny)
712 self.assertRaises(OverflowError, dt.__add__, -tiny)
713
714 dt = self.theclass.max - tiny
715 dt += tiny # no problem
716 self.assertRaises(OverflowError, dt.__add__, tiny)
717 self.assertRaises(OverflowError, dt.__sub__, -tiny)
718
719 def test_fromtimestamp(self):
720 import time
721
722 # Try an arbitrary fixed value.
723 year, month, day = 1999, 9, 19
724 ts = time.mktime((year, month, day, 0, 0, 0, 0, 0, -1))
725 d = self.theclass.fromtimestamp(ts)
726 self.assertEqual(d.year, year)
727 self.assertEqual(d.month, month)
728 self.assertEqual(d.day, day)
729
730 def test_today(self):
731 import time
732
733 # We claim that today() is like fromtimestamp(time.time()), so
734 # prove it.
735 for dummy in range(3):
736 today = self.theclass.today()
737 ts = time.time()
738 todayagain = self.theclass.fromtimestamp(ts)
739 if today == todayagain:
740 break
741 # There are several legit reasons that could fail:
742 # 1. It recently became midnight, between the today() and the
743 # time() calls.
744 # 2. The platform time() has such fine resolution that we'll
745 # never get the same value twice.
746 # 3. The platform time() has poor resolution, and we just
747 # happened to call today() right before a resolution quantum
748 # boundary.
749 # 4. The system clock got fiddled between calls.
750 # In any case, wait a little while and try again.
751 time.sleep(0.1)
752
753 # It worked or it didn't. If it didn't, assume it's reason #2, and
754 # let the test pass if they're within half a second of each other.
755 self.failUnless(today == todayagain or
756 abs(todayagain - today) < timedelta(seconds=0.5))
757
758 def test_weekday(self):
759 for i in range(7):
760 # March 4, 2002 is a Monday
761 self.assertEqual(self.theclass(2002, 3, 4+i).weekday(), i)
762 self.assertEqual(self.theclass(2002, 3, 4+i).isoweekday(), i+1)
763 # January 2, 1956 is a Monday
764 self.assertEqual(self.theclass(1956, 1, 2+i).weekday(), i)
765 self.assertEqual(self.theclass(1956, 1, 2+i).isoweekday(), i+1)
766
767 def test_isocalendar(self):
768 # Check examples from
769 # http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
770 for i in range(7):
771 d = self.theclass(2003, 12, 22+i)
772 self.assertEqual(d.isocalendar(), (2003, 52, i+1))
773 d = self.theclass(2003, 12, 29) + timedelta(i)
774 self.assertEqual(d.isocalendar(), (2004, 1, i+1))
775 d = self.theclass(2004, 1, 5+i)
776 self.assertEqual(d.isocalendar(), (2004, 2, i+1))
777 d = self.theclass(2009, 12, 21+i)
778 self.assertEqual(d.isocalendar(), (2009, 52, i+1))
779 d = self.theclass(2009, 12, 28) + timedelta(i)
780 self.assertEqual(d.isocalendar(), (2009, 53, i+1))
781 d = self.theclass(2010, 1, 4+i)
782 self.assertEqual(d.isocalendar(), (2010, 1, i+1))
783
784 def test_iso_long_years(self):
785 # Calculate long ISO years and compare to table from
786 # http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
787 ISO_LONG_YEARS_TABLE = """
788 4 32 60 88
789 9 37 65 93
790 15 43 71 99
791 20 48 76
792 26 54 82
793
794 105 133 161 189
795 111 139 167 195
796 116 144 172
797 122 150 178
798 128 156 184
799
800 201 229 257 285
801 207 235 263 291
802 212 240 268 296
803 218 246 274
804 224 252 280
805
806 303 331 359 387
807 308 336 364 392
808 314 342 370 398
809 320 348 376
810 325 353 381
811 """
812 iso_long_years = map(int, ISO_LONG_YEARS_TABLE.split())
813 iso_long_years.sort()
814 L = []
815 for i in range(400):
816 d = self.theclass(2000+i, 12, 31)
817 d1 = self.theclass(1600+i, 12, 31)
818 self.assertEqual(d.isocalendar()[1:], d1.isocalendar()[1:])
819 if d.isocalendar()[1] == 53:
820 L.append(i)
821 self.assertEqual(L, iso_long_years)
822
823 def test_isoformat(self):
824 t = self.theclass(2, 3, 2)
825 self.assertEqual(t.isoformat(), "0002-03-02")
826
827 def test_ctime(self):
828 t = self.theclass(2002, 3, 2)
829 self.assertEqual(t.ctime(), "Sat Mar 2 00:00:00 2002")
830
831 def test_strftime(self):
832 t = self.theclass(2005, 3, 2)
833 self.assertEqual(t.strftime("m:%m d:%d y:%y"), "m:03 d:02 y:05")
834 self.assertEqual(t.strftime(""), "") # SF bug #761337
835
836 self.assertRaises(TypeError, t.strftime) # needs an arg
837 self.assertRaises(TypeError, t.strftime, "one", "two") # too many args
838 self.assertRaises(TypeError, t.strftime, 42) # arg wrong type
839
840 # A naive object replaces %z and %Z w/ empty strings.
841 self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")
842
843 def test_resolution_info(self):
844 self.assert_(isinstance(self.theclass.min, self.theclass))
845 self.assert_(isinstance(self.theclass.max, self.theclass))
846 self.assert_(isinstance(self.theclass.resolution, timedelta))
847 self.assert_(self.theclass.max > self.theclass.min)
848
849 def test_extreme_timedelta(self):
850 big = self.theclass.max - self.theclass.min
851 # 3652058 days, 23 hours, 59 minutes, 59 seconds, 999999 microseconds
852 n = (big.days*24*3600 + big.seconds)*1000000 + big.microseconds
853 # n == 315537897599999999 ~= 2**58.13
854 justasbig = timedelta(0, 0, n)
855 self.assertEqual(big, justasbig)
856 self.assertEqual(self.theclass.min + big, self.theclass.max)
857 self.assertEqual(self.theclass.max - big, self.theclass.min)
858
859 def test_timetuple(self):
860 for i in range(7):
861 # January 2, 1956 is a Monday (0)
862 d = self.theclass(1956, 1, 2+i)
863 t = d.timetuple()
864 self.assertEqual(t, (1956, 1, 2+i, 0, 0, 0, i, 2+i, -1))
865 # February 1, 1956 is a Wednesday (2)
866 d = self.theclass(1956, 2, 1+i)
867 t = d.timetuple()
868 self.assertEqual(t, (1956, 2, 1+i, 0, 0, 0, (2+i)%7, 32+i, -1))
869 # March 1, 1956 is a Thursday (3), and is the 31+29+1 = 61st day
870 # of the year.
871 d = self.theclass(1956, 3, 1+i)
872 t = d.timetuple()
873 self.assertEqual(t, (1956, 3, 1+i, 0, 0, 0, (3+i)%7, 61+i, -1))
874 self.assertEqual(t.tm_year, 1956)
875 self.assertEqual(t.tm_mon, 3)
876 self.assertEqual(t.tm_mday, 1+i)
877 self.assertEqual(t.tm_hour, 0)
878 self.assertEqual(t.tm_min, 0)
879 self.assertEqual(t.tm_sec, 0)
880 self.assertEqual(t.tm_wday, (3+i)%7)
881 self.assertEqual(t.tm_yday, 61+i)
882 self.assertEqual(t.tm_isdst, -1)
883
884 def test_pickling(self):
885 args = 6, 7, 23
886 orig = self.theclass(*args)
887 for pickler, unpickler, proto in pickle_choices:
888 green = pickler.dumps(orig, proto)
889 derived = unpickler.loads(green)
890 self.assertEqual(orig, derived)
891
892 def test_compare(self):
893 t1 = self.theclass(2, 3, 4)
894 t2 = self.theclass(2, 3, 4)
895 self.failUnless(t1 == t2)
896 self.failUnless(t1 <= t2)
897 self.failUnless(t1 >= t2)
898 self.failUnless(not t1 != t2)
899 self.failUnless(not t1 < t2)
900 self.failUnless(not t1 > t2)
901 self.assertEqual(cmp(t1, t2), 0)
902 self.assertEqual(cmp(t2, t1), 0)
903
904 for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
905 t2 = self.theclass(*args) # this is larger than t1
906 self.failUnless(t1 < t2)
907 self.failUnless(t2 > t1)
908 self.failUnless(t1 <= t2)
909 self.failUnless(t2 >= t1)
910 self.failUnless(t1 != t2)
911 self.failUnless(t2 != t1)
912 self.failUnless(not t1 == t2)
913 self.failUnless(not t2 == t1)
914 self.failUnless(not t1 > t2)
915 self.failUnless(not t2 < t1)
916 self.failUnless(not t1 >= t2)
917 self.failUnless(not t2 <= t1)
918 self.assertEqual(cmp(t1, t2), -1)
919 self.assertEqual(cmp(t2, t1), 1)
920
921 for badarg in OTHERSTUFF:
922 self.assertEqual(t1 == badarg, False)
923 self.assertEqual(t1 != badarg, True)
924 self.assertEqual(badarg == t1, False)
925 self.assertEqual(badarg != t1, True)
926
927 self.assertRaises(TypeError, lambda: t1 < badarg)
928 self.assertRaises(TypeError, lambda: t1 > badarg)
929 self.assertRaises(TypeError, lambda: t1 >= badarg)
930 self.assertRaises(TypeError, lambda: badarg <= t1)
931 self.assertRaises(TypeError, lambda: badarg < t1)
932 self.assertRaises(TypeError, lambda: badarg > t1)
933 self.assertRaises(TypeError, lambda: badarg >= t1)
934
935 def test_mixed_compare(self):
936 our = self.theclass(2000, 4, 5)
937 self.assertRaises(TypeError, cmp, our, 1)
938 self.assertRaises(TypeError, cmp, 1, our)
939
940 class AnotherDateTimeClass(object):
941 def __cmp__(self, other):
942 # Return "equal" so calling this can't be confused with
943 # compare-by-address (which never says "equal" for distinct
944 # objects).
945 return 0
946
947 # This still errors, because date and datetime comparison raise
948 # TypeError instead of NotImplemented when they don't know what to
949 # do, in order to stop comparison from falling back to the default
950 # compare-by-address.
951 their = AnotherDateTimeClass()
952 self.assertRaises(TypeError, cmp, our, their)
953 # Oops: The next stab raises TypeError in the C implementation,
954 # but not in the Python implementation of datetime. The difference
955 # is due to that the Python implementation defines __cmp__ but
956 # the C implementation defines tp_richcompare. This is more pain
957 # to fix than it's worth, so commenting out the test.
958 # self.assertEqual(cmp(their, our), 0)
959
960 # But date and datetime comparison return NotImplemented instead if the
961 # other object has a timetuple attr. This gives the other object a
962 # chance to do the comparison.
963 class Comparable(AnotherDateTimeClass):
964 def timetuple(self):
965 return ()
966
967 their = Comparable()
968 self.assertEqual(cmp(our, their), 0)
969 self.assertEqual(cmp(their, our), 0)
970 self.failUnless(our == their)
971 self.failUnless(their == our)
972
973 def test_bool(self):
974 # All dates are considered true.
975 self.failUnless(self.theclass.min)
976 self.failUnless(self.theclass.max)
977
978 def test_srftime_out_of_range(self):
979 # For nasty technical reasons, we can't handle years before 1900.
980 cls = self.theclass
981 self.assertEqual(cls(1900, 1, 1).strftime("%Y"), "1900")
982 for y in 1, 49, 51, 99, 100, 1000, 1899:
983 self.assertRaises(ValueError, cls(y, 1, 1).strftime, "%Y")
984
985 def test_replace(self):
986 cls = self.theclass
987 args = [1, 2, 3]
988 base = cls(*args)
989 self.assertEqual(base, base.replace())
990
991 i = 0
992 for name, newval in (("year", 2),
993 ("month", 3),
994 ("day", 4)):
995 newargs = args[:]
996 newargs[i] = newval
997 expected = cls(*newargs)
998 got = base.replace(**{name: newval})
999 self.assertEqual(expected, got)
1000 i += 1
1001
1002 # Out of bounds.
1003 base = cls(2000, 2, 29)
1004 self.assertRaises(ValueError, base.replace, year=2001)
1005
1006 def test_subclass_date(self):
1007
1008 class C(self.theclass):
1009 theAnswer = 42
1010
1011 def __new__(cls, *args, **kws):
1012 temp = kws.copy()
1013 extra = temp.pop('extra')
1014 result = self.theclass.__new__(cls, *args, **temp)
1015 result.extra = extra
1016 return result
1017
1018 def newmeth(self, start):
1019 return start + self.year + self.month
1020
1021 args = 2003, 4, 14
1022
1023 dt1 = self.theclass(*args)
1024 dt2 = C(*args, **{'extra': 7})
1025
1026 self.assertEqual(dt2.__class__, C)
1027 self.assertEqual(dt2.theAnswer, 42)
1028 self.assertEqual(dt2.extra, 7)
1029 self.assertEqual(dt1.toordinal(), dt2.toordinal())
1030 self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month - 7)
1031
1032
1033 #############################################################################
1034 # datetime tests
1035
1036 class TestDateTime(TestDate):
1037
1038 theclass = datetime
1039
1040 def test_basic_attributes(self):
1041 dt = self.theclass(2002, 3, 1, 12, 0)
1042 self.assertEqual(dt.year, 2002)
1043 self.assertEqual(dt.month, 3)
1044 self.assertEqual(dt.day, 1)
1045 self.assertEqual(dt.hour, 12)
1046 self.assertEqual(dt.minute, 0)
1047 self.assertEqual(dt.second, 0)
1048 self.assertEqual(dt.microsecond, 0)
1049
1050 def test_basic_attributes_nonzero(self):
1051 # Make sure all attributes are non-zero so bugs in
1052 # bit-shifting access show up.
1053 dt = self.theclass(2002, 3, 1, 12, 59, 59, 8000)
1054 self.assertEqual(dt.year, 2002)
1055 self.assertEqual(dt.month, 3)
1056 self.assertEqual(dt.day, 1)
1057 self.assertEqual(dt.hour, 12)
1058 self.assertEqual(dt.minute, 59)
1059 self.assertEqual(dt.second, 59)
1060 self.assertEqual(dt.microsecond, 8000)
1061
1062 def test_roundtrip(self):
1063 for dt in (self.theclass(1, 2, 3, 4, 5, 6, 7),
1064 self.theclass.now()):
1065 # Verify dt -> string -> datetime identity.
1066 s = repr(dt)
1067 self.failUnless(s.startswith('datetime.'))
1068 s = s[9:]
1069 dt2 = eval(s)
1070 self.assertEqual(dt, dt2)
1071
1072 # Verify identity via reconstructing from pieces.
1073 dt2 = self.theclass(dt.year, dt.month, dt.day,
1074 dt.hour, dt.minute, dt.second,
1075 dt.microsecond)
1076 self.assertEqual(dt, dt2)
1077
1078 def test_isoformat(self):
1079 t = self.theclass(2, 3, 2, 4, 5, 1, 123)
1080 self.assertEqual(t.isoformat(), "0002-03-02T04:05:01.000123")
1081 self.assertEqual(t.isoformat('T'), "0002-03-02T04:05:01.000123")
1082 self.assertEqual(t.isoformat(' '), "0002-03-02 04:05:01.000123")
1083 # str is ISO format with the separator forced to a blank.
1084 self.assertEqual(str(t), "0002-03-02 04:05:01.000123")
1085
1086 t = self.theclass(2, 3, 2)
1087 self.assertEqual(t.isoformat(), "0002-03-02T00:00:00")
1088 self.assertEqual(t.isoformat('T'), "0002-03-02T00:00:00")
1089 self.assertEqual(t.isoformat(' '), "0002-03-02 00:00:00")
1090 # str is ISO format with the separator forced to a blank.
1091 self.assertEqual(str(t), "0002-03-02 00:00:00")
1092
1093 def test_more_ctime(self):
1094 # Test fields that TestDate doesn't touch.
1095 import time
1096
1097 t = self.theclass(2002, 3, 2, 18, 3, 5, 123)
1098 self.assertEqual(t.ctime(), "Sat Mar 2 18:03:05 2002")
1099 # Oops! The next line fails on Win2K under MSVC 6, so it's commented
1100 # out. The difference is that t.ctime() produces " 2" for the day,
1101 # but platform ctime() produces "02" for the day. According to
1102 # C99, t.ctime() is correct here.
1103 # self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))
1104
1105 # So test a case where that difference doesn't matter.
1106 t = self.theclass(2002, 3, 22, 18, 3, 5, 123)
1107 self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))
1108
1109 def test_tz_independent_comparing(self):
1110 dt1 = self.theclass(2002, 3, 1, 9, 0, 0)
1111 dt2 = self.theclass(2002, 3, 1, 10, 0, 0)
1112 dt3 = self.theclass(2002, 3, 1, 9, 0, 0)
1113 self.assertEqual(dt1, dt3)
1114 self.assert_(dt2 > dt3)
1115
1116 # Make sure comparison doesn't forget microseconds, and isn't done
1117 # via comparing a float timestamp (an IEEE double doesn't have enough
1118 # precision to span microsecond resolution across years 1 thru 9999,
1119 # so comparing via timestamp necessarily calls some distinct values
1120 # equal).
1121 dt1 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999998)
1122 us = timedelta(microseconds=1)
1123 dt2 = dt1 + us
1124 self.assertEqual(dt2 - dt1, us)
1125 self.assert_(dt1 < dt2)
1126
1127 def test_bad_constructor_arguments(self):
1128 # bad years
1129 self.theclass(MINYEAR, 1, 1) # no exception
1130 self.theclass(MAXYEAR, 1, 1) # no exception
1131 self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)
1132 self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)
1133 # bad months
1134 self.theclass(2000, 1, 1) # no exception
1135 self.theclass(2000, 12, 1) # no exception
1136 self.assertRaises(ValueError, self.theclass, 2000, 0, 1)
1137 self.assertRaises(ValueError, self.theclass, 2000, 13, 1)
1138 # bad days
1139 self.theclass(2000, 2, 29) # no exception
1140 self.theclass(2004, 2, 29) # no exception
1141 self.theclass(2400, 2, 29) # no exception
1142 self.assertRaises(ValueError, self.theclass, 2000, 2, 30)
1143 self.assertRaises(ValueError, self.theclass, 2001, 2, 29)
1144 self.assertRaises(ValueError, self.theclass, 2100, 2, 29)
1145 self.assertRaises(ValueError, self.theclass, 1900, 2, 29)
1146 self.assertRaises(ValueError, self.theclass, 2000, 1, 0)
1147 self.assertRaises(ValueError, self.theclass, 2000, 1, 32)
1148 # bad hours
1149 self.theclass(2000, 1, 31, 0) # no exception
1150 self.theclass(2000, 1, 31, 23) # no exception
1151 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, -1)
1152 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 24)
1153 # bad minutes
1154 self.theclass(2000, 1, 31, 23, 0) # no exception
1155 self.theclass(2000, 1, 31, 23, 59) # no exception
1156 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, -1)
1157 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 60)
1158 # bad seconds
1159 self.theclass(2000, 1, 31, 23, 59, 0) # no exception
1160 self.theclass(2000, 1, 31, 23, 59, 59) # no exception
1161 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, -1)
1162 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, 60)
1163 # bad microseconds
1164 self.theclass(2000, 1, 31, 23, 59, 59, 0) # no exception
1165 self.theclass(2000, 1, 31, 23, 59, 59, 999999) # no exception
1166 self.assertRaises(ValueError, self.theclass,
1167 2000, 1, 31, 23, 59, 59, -1)
1168 self.assertRaises(ValueError, self.theclass,
1169 2000, 1, 31, 23, 59, 59,
1170 1000000)
1171
1172 def test_hash_equality(self):
1173 d = self.theclass(2000, 12, 31, 23, 30, 17)
1174 e = self.theclass(2000, 12, 31, 23, 30, 17)
1175 self.assertEqual(d, e)
1176 self.assertEqual(hash(d), hash(e))
1177
1178 dic = {d: 1}
1179 dic[e] = 2
1180 self.assertEqual(len(dic), 1)
1181 self.assertEqual(dic[d], 2)
1182 self.assertEqual(dic[e], 2)
1183
1184 d = self.theclass(2001, 1, 1, 0, 5, 17)
1185 e = self.theclass(2001, 1, 1, 0, 5, 17)
1186 self.assertEqual(d, e)
1187 self.assertEqual(hash(d), hash(e))
1188
1189 dic = {d: 1}
1190 dic[e] = 2
1191 self.assertEqual(len(dic), 1)
1192 self.assertEqual(dic[d], 2)
1193 self.assertEqual(dic[e], 2)
1194
1195 def test_computations(self):
1196 a = self.theclass(2002, 1, 31)
1197 b = self.theclass(1956, 1, 31)
1198 diff = a-b
1199 self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))
1200 self.assertEqual(diff.seconds, 0)
1201 self.assertEqual(diff.microseconds, 0)
1202 a = self.theclass(2002, 3, 2, 17, 6)
1203 millisec = timedelta(0, 0, 1000)
1204 hour = timedelta(0, 3600)
1205 day = timedelta(1)
1206 week = timedelta(7)
1207 self.assertEqual(a + hour, self.theclass(2002, 3, 2, 18, 6))
1208 self.assertEqual(hour + a, self.theclass(2002, 3, 2, 18, 6))
1209 self.assertEqual(a + 10*hour, self.theclass(2002, 3, 3, 3, 6))
1210 self.assertEqual(a - hour, self.theclass(2002, 3, 2, 16, 6))
1211 self.assertEqual(-hour + a, self.theclass(2002, 3, 2, 16, 6))
1212 self.assertEqual(a - hour, a + -hour)
1213 self.assertEqual(a - 20*hour, self.theclass(2002, 3, 1, 21, 6))
1214 self.assertEqual(a + day, self.theclass(2002, 3, 3, 17, 6))
1215 self.assertEqual(a - day, self.theclass(2002, 3, 1, 17, 6))
1216 self.assertEqual(a + week, self.theclass(2002, 3, 9, 17, 6))
1217 self.assertEqual(a - week, self.theclass(2002, 2, 23, 17, 6))
1218 self.assertEqual(a + 52*week, self.theclass(2003, 3, 1, 17, 6))
1219 self.assertEqual(a - 52*week, self.theclass(2001, 3, 3, 17, 6))
1220 self.assertEqual((a + week) - a, week)
1221 self.assertEqual((a + day) - a, day)
1222 self.assertEqual((a + hour) - a, hour)
1223 self.assertEqual((a + millisec) - a, millisec)
1224 self.assertEqual((a - week) - a, -week)
1225 self.assertEqual((a - day) - a, -day)
1226 self.assertEqual((a - hour) - a, -hour)
1227 self.assertEqual((a - millisec) - a, -millisec)
1228 self.assertEqual(a - (a + week), -week)
1229 self.assertEqual(a - (a + day), -day)
1230 self.assertEqual(a - (a + hour), -hour)
1231 self.assertEqual(a - (a + millisec), -millisec)
1232 self.assertEqual(a - (a - week), week)
1233 self.assertEqual(a - (a - day), day)
1234 self.assertEqual(a - (a - hour), hour)
1235 self.assertEqual(a - (a - millisec), millisec)
1236 self.assertEqual(a + (week + day + hour + millisec),
1237 self.theclass(2002, 3, 10, 18, 6, 0, 1000))
1238 self.assertEqual(a + (week + day + hour + millisec),
1239 (((a + week) + day) + hour) + millisec)
1240 self.assertEqual(a - (week + day + hour + millisec),
1241 self.theclass(2002, 2, 22, 16, 5, 59, 999000))
1242 self.assertEqual(a - (week + day + hour + millisec),
1243 (((a - week) - day) - hour) - millisec)
1244 # Add/sub ints, longs, floats should be illegal
1245 for i in 1, 1L, 1.0:
1246 self.assertRaises(TypeError, lambda: a+i)
1247 self.assertRaises(TypeError, lambda: a-i)
1248 self.assertRaises(TypeError, lambda: i+a)
1249 self.assertRaises(TypeError, lambda: i-a)
1250
1251 # delta - datetime is senseless.
1252 self.assertRaises(TypeError, lambda: day - a)
1253 # mixing datetime and (delta or datetime) via * or // is senseless
1254 self.assertRaises(TypeError, lambda: day * a)
1255 self.assertRaises(TypeError, lambda: a * day)
1256 self.assertRaises(TypeError, lambda: day // a)
1257 self.assertRaises(TypeError, lambda: a // day)
1258 self.assertRaises(TypeError, lambda: a * a)
1259 self.assertRaises(TypeError, lambda: a // a)
1260 # datetime + datetime is senseless
1261 self.assertRaises(TypeError, lambda: a + a)
1262
1263 def test_pickling(self):
1264 args = 6, 7, 23, 20, 59, 1, 64**2
1265 orig = self.theclass(*args)
1266 for pickler, unpickler, proto in pickle_choices:
1267 green = pickler.dumps(orig, proto)
1268 derived = unpickler.loads(green)
1269 self.assertEqual(orig, derived)
1270
1271 def test_more_pickling(self):
1272 a = self.theclass(2003, 2, 7, 16, 48, 37, 444116)
1273 s = pickle.dumps(a)
1274 b = pickle.loads(s)
1275 self.assertEqual(b.year, 2003)
1276 self.assertEqual(b.month, 2)
1277 self.assertEqual(b.day, 7)
1278
1279 def test_more_compare(self):
1280 # The test_compare() inherited from TestDate covers the error cases.
1281 # We just want to test lexicographic ordering on the members datetime
1282 # has that date lacks.
1283 args = [2000, 11, 29, 20, 58, 16, 999998]
1284 t1 = self.theclass(*args)
1285 t2 = self.theclass(*args)
1286 self.failUnless(t1 == t2)
1287 self.failUnless(t1 <= t2)
1288 self.failUnless(t1 >= t2)
1289 self.failUnless(not t1 != t2)
1290 self.failUnless(not t1 < t2)
1291 self.failUnless(not t1 > t2)
1292 self.assertEqual(cmp(t1, t2), 0)
1293 self.assertEqual(cmp(t2, t1), 0)
1294
1295 for i in range(len(args)):
1296 newargs = args[:]
1297 newargs[i] = args[i] + 1
1298 t2 = self.theclass(*newargs) # this is larger than t1
1299 self.failUnless(t1 < t2)
1300 self.failUnless(t2 > t1)
1301 self.failUnless(t1 <= t2)
1302 self.failUnless(t2 >= t1)
1303 self.failUnless(t1 != t2)
1304 self.failUnless(t2 != t1)
1305 self.failUnless(not t1 == t2)
1306 self.failUnless(not t2 == t1)
1307 self.failUnless(not t1 > t2)
1308 self.failUnless(not t2 < t1)
1309 self.failUnless(not t1 >= t2)
1310 self.failUnless(not t2 <= t1)
1311 self.assertEqual(cmp(t1, t2), -1)
1312 self.assertEqual(cmp(t2, t1), 1)
1313
1314
1315 # A helper for timestamp constructor tests.
1316 def verify_field_equality(self, expected, got):
1317 self.assertEqual(expected.tm_year, got.year)
1318 self.assertEqual(expected.tm_mon, got.month)
1319 self.assertEqual(expected.tm_mday, got.day)
1320 self.assertEqual(expected.tm_hour, got.hour)
1321 self.assertEqual(expected.tm_min, got.minute)
1322 self.assertEqual(expected.tm_sec, got.second)
1323
1324 def test_fromtimestamp(self):
1325 import time
1326
1327 ts = time.time()
1328 expected = time.localtime(ts)
1329 got = self.theclass.fromtimestamp(ts)
1330 self.verify_field_equality(expected, got)
1331
1332 def test_utcfromtimestamp(self):
1333 import time
1334
1335 ts = time.time()
1336 expected = time.gmtime(ts)
1337 got = self.theclass.utcfromtimestamp(ts)
1338 self.verify_field_equality(expected, got)
1339
1340 def test_utcnow(self):
1341 import time
1342
1343 # Call it a success if utcnow() and utcfromtimestamp() are within
1344 # a second of each other.
1345 tolerance = timedelta(seconds=1)
1346 for dummy in range(3):
1347 from_now = self.theclass.utcnow()
1348 from_timestamp = self.theclass.utcfromtimestamp(time.time())
1349 if abs(from_timestamp - from_now) <= tolerance:
1350 break
1351 # Else try again a few times.
1352 self.failUnless(abs(from_timestamp - from_now) <= tolerance)
1353
1354 def test_more_timetuple(self):
1355 # This tests fields beyond those tested by the TestDate.test_timetuple.
1356 t = self.theclass(2004, 12, 31, 6, 22, 33)
1357 self.assertEqual(t.timetuple(), (2004, 12, 31, 6, 22, 33, 4, 366, -1))
1358 self.assertEqual(t.timetuple(),
1359 (t.year, t.month, t.day,
1360 t.hour, t.minute, t.second,
1361 t.weekday(),
1362 t.toordinal() - date(t.year, 1, 1).toordinal() + 1,
1363 -1))
1364 tt = t.timetuple()
1365 self.assertEqual(tt.tm_year, t.year)
1366 self.assertEqual(tt.tm_mon, t.month)
1367 self.assertEqual(tt.tm_mday, t.day)
1368 self.assertEqual(tt.tm_hour, t.hour)
1369 self.assertEqual(tt.tm_min, t.minute)
1370 self.assertEqual(tt.tm_sec, t.second)
1371 self.assertEqual(tt.tm_wday, t.weekday())
1372 self.assertEqual(tt.tm_yday, t.toordinal() -
1373 date(t.year, 1, 1).toordinal() + 1)
1374 self.assertEqual(tt.tm_isdst, -1)
1375
1376 def test_more_strftime(self):
1377 # This tests fields beyond those tested by the TestDate.test_strftime.
1378 t = self.theclass(2004, 12, 31, 6, 22, 33)
1379 self.assertEqual(t.strftime("%m %d %y %S %M %H %j"),
1380 "12 31 04 33 22 06 366")
1381
1382 def test_extract(self):
1383 dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
1384 self.assertEqual(dt.date(), date(2002, 3, 4))
1385 self.assertEqual(dt.time(), time(18, 45, 3, 1234))
1386
1387 def test_combine(self):
1388 d = date(2002, 3, 4)
1389 t = time(18, 45, 3, 1234)
1390 expected = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
1391 combine = self.theclass.combine
1392 dt = combine(d, t)
1393 self.assertEqual(dt, expected)
1394
1395 dt = combine(time=t, date=d)
1396 self.assertEqual(dt, expected)
1397
1398 self.assertEqual(d, dt.date())
1399 self.assertEqual(t, dt.time())
1400 self.assertEqual(dt, combine(dt.date(), dt.time()))
1401
1402 self.assertRaises(TypeError, combine) # need an arg
1403 self.assertRaises(TypeError, combine, d) # need two args
1404 self.assertRaises(TypeError, combine, t, d) # args reversed
1405 self.assertRaises(TypeError, combine, d, t, 1) # too many args
1406 self.assertRaises(TypeError, combine, "date", "time") # wrong types
1407
1408 def test_replace(self):
1409 cls = self.theclass
1410 args = [1, 2, 3, 4, 5, 6, 7]
1411 base = cls(*args)
1412 self.assertEqual(base, base.replace())
1413
1414 i = 0
1415 for name, newval in (("year", 2),
1416 ("month", 3),
1417 ("day", 4),
1418 ("hour", 5),
1419 ("minute", 6),
1420 ("second", 7),
1421 ("microsecond", 8)):
1422 newargs = args[:]
1423 newargs[i] = newval
1424 expected = cls(*newargs)
1425 got = base.replace(**{name: newval})
1426 self.assertEqual(expected, got)
1427 i += 1
1428
1429 # Out of bounds.
1430 base = cls(2000, 2, 29)
1431 self.assertRaises(ValueError, base.replace, year=2001)
1432
1433 def test_astimezone(self):
1434 # Pretty boring! The TZ test is more interesting here. astimezone()
1435 # simply can't be applied to a naive object.
1436 dt = self.theclass.now()
1437 f = FixedOffset(44, "")
1438 self.assertRaises(TypeError, dt.astimezone) # not enough args
1439 self.assertRaises(TypeError, dt.astimezone, f, f) # too many args
1440 self.assertRaises(TypeError, dt.astimezone, dt) # arg wrong type
1441 self.assertRaises(ValueError, dt.astimezone, f) # naive
1442 self.assertRaises(ValueError, dt.astimezone, tz=f) # naive
1443
1444 class Bogus(tzinfo):
1445 def utcoffset(self, dt): return None
1446 def dst(self, dt): return timedelta(0)
1447 bog = Bogus()
1448 self.assertRaises(ValueError, dt.astimezone, bog) # naive
1449
1450 class AlsoBogus(tzinfo):
1451 def utcoffset(self, dt): return timedelta(0)
1452 def dst(self, dt): return None
1453 alsobog = AlsoBogus()
1454 self.assertRaises(ValueError, dt.astimezone, alsobog) # also naive
1455
1456 def test_subclass_datetime(self):
1457
1458 class C(self.theclass):
1459 theAnswer = 42
1460
1461 def __new__(cls, *args, **kws):
1462 temp = kws.copy()
1463 extra = temp.pop('extra')
1464 result = self.theclass.__new__(cls, *args, **temp)
1465 result.extra = extra
1466 return result
1467
1468 def newmeth(self, start):
1469 return start + self.year + self.month + self.second
1470
1471 args = 2003, 4, 14, 12, 13, 41
1472
1473 dt1 = self.theclass(*args)
1474 dt2 = C(*args, **{'extra': 7})
1475
1476 self.assertEqual(dt2.__class__, C)
1477 self.assertEqual(dt2.theAnswer, 42)
1478 self.assertEqual(dt2.extra, 7)
1479 self.assertEqual(dt1.toordinal(), dt2.toordinal())
1480 self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month +
1481 dt1.second - 7)
1482
1483 class TestTime(HarmlessMixedComparison):
1484
1485 theclass = time
1486
1487 def test_basic_attributes(self):
1488 t = self.theclass(12, 0)
1489 self.assertEqual(t.hour, 12)
1490 self.assertEqual(t.minute, 0)
1491 self.assertEqual(t.second, 0)
1492 self.assertEqual(t.microsecond, 0)
1493
1494 def test_basic_attributes_nonzero(self):
1495 # Make sure all attributes are non-zero so bugs in
1496 # bit-shifting access show up.
1497 t = self.theclass(12, 59, 59, 8000)
1498 self.assertEqual(t.hour, 12)
1499 self.assertEqual(t.minute, 59)
1500 self.assertEqual(t.second, 59)
1501 self.assertEqual(t.microsecond, 8000)
1502
1503 def test_roundtrip(self):
1504 t = self.theclass(1, 2, 3, 4)
1505
1506 # Verify t -> string -> time identity.
1507 s = repr(t)
1508 self.failUnless(s.startswith('datetime.'))
1509 s = s[9:]
1510 t2 = eval(s)
1511 self.assertEqual(t, t2)
1512
1513 # Verify identity via reconstructing from pieces.
1514 t2 = self.theclass(t.hour, t.minute, t.second,
1515 t.microsecond)
1516 self.assertEqual(t, t2)
1517
1518 def test_comparing(self):
1519 args = [1, 2, 3, 4]
1520 t1 = self.theclass(*args)
1521 t2 = self.theclass(*args)
1522 self.failUnless(t1 == t2)
1523 self.failUnless(t1 <= t2)
1524 self.failUnless(t1 >= t2)
1525 self.failUnless(not t1 != t2)
1526 self.failUnless(not t1 < t2)
1527 self.failUnless(not t1 > t2)
1528 self.assertEqual(cmp(t1, t2), 0)
1529 self.assertEqual(cmp(t2, t1), 0)
1530
1531 for i in range(len(args)):
1532 newargs = args[:]
1533 newargs[i] = args[i] + 1
1534 t2 = self.theclass(*newargs) # this is larger than t1
1535 self.failUnless(t1 < t2)
1536 self.failUnless(t2 > t1)
1537 self.failUnless(t1 <= t2)
1538 self.failUnless(t2 >= t1)
1539 self.failUnless(t1 != t2)
1540 self.failUnless(t2 != t1)
1541 self.failUnless(not t1 == t2)
1542 self.failUnless(not t2 == t1)
1543 self.failUnless(not t1 > t2)
1544 self.failUnless(not t2 < t1)
1545 self.failUnless(not t1 >= t2)
1546 self.failUnless(not t2 <= t1)
1547 self.assertEqual(cmp(t1, t2), -1)
1548 self.assertEqual(cmp(t2, t1), 1)
1549
1550 for badarg in OTHERSTUFF:
1551 self.assertEqual(t1 == badarg, False)
1552 self.assertEqual(t1 != badarg, True)
1553 self.assertEqual(badarg == t1, False)
1554 self.assertEqual(badarg != t1, True)
1555
1556 self.assertRaises(TypeError, lambda: t1 <= badarg)
1557 self.assertRaises(TypeError, lambda: t1 < badarg)
1558 self.assertRaises(TypeError, lambda: t1 > badarg)
1559 self.assertRaises(TypeError, lambda: t1 >= badarg)
1560 self.assertRaises(TypeError, lambda: badarg <= t1)
1561 self.assertRaises(TypeError, lambda: badarg < t1)
1562 self.assertRaises(TypeError, lambda: badarg > t1)
1563 self.assertRaises(TypeError, lambda: badarg >= t1)
1564
1565 def test_bad_constructor_arguments(self):
1566 # bad hours
1567 self.theclass(0, 0) # no exception
1568 self.theclass(23, 0) # no exception
1569 self.assertRaises(ValueError, self.theclass, -1, 0)
1570 self.assertRaises(ValueError, self.theclass, 24, 0)
1571 # bad minutes
1572 self.theclass(23, 0) # no exception
1573 self.theclass(23, 59) # no exception
1574 self.assertRaises(ValueError, self.theclass, 23, -1)
1575 self.assertRaises(ValueError, self.theclass, 23, 60)
1576 # bad seconds
1577 self.theclass(23, 59, 0) # no exception
1578 self.theclass(23, 59, 59) # no exception
1579 self.assertRaises(ValueError, self.theclass, 23, 59, -1)
1580 self.assertRaises(ValueError, self.theclass, 23, 59, 60)
1581 # bad microseconds
1582 self.theclass(23, 59, 59, 0) # no exception
1583 self.theclass(23, 59, 59, 999999) # no exception
1584 self.assertRaises(ValueError, self.theclass, 23, 59, 59, -1)
1585 self.assertRaises(ValueError, self.theclass, 23, 59, 59, 1000000)
1586
1587 def test_hash_equality(self):
1588 d = self.theclass(23, 30, 17)
1589 e = self.theclass(23, 30, 17)
1590 self.assertEqual(d, e)
1591 self.assertEqual(hash(d), hash(e))
1592
1593 dic = {d: 1}
1594 dic[e] = 2
1595 self.assertEqual(len(dic), 1)
1596 self.assertEqual(dic[d], 2)
1597 self.assertEqual(dic[e], 2)
1598
1599 d = self.theclass(0, 5, 17)
1600 e = self.theclass(0, 5, 17)
1601 self.assertEqual(d, e)
1602 self.assertEqual(hash(d), hash(e))
1603
1604 dic = {d: 1}
1605 dic[e] = 2
1606 self.assertEqual(len(dic), 1)
1607 self.assertEqual(dic[d], 2)
1608 self.assertEqual(dic[e], 2)
1609
1610 def test_isoformat(self):
1611 t = self.theclass(4, 5, 1, 123)
1612 self.assertEqual(t.isoformat(), "04:05:01.000123")
1613 self.assertEqual(t.isoformat(), str(t))
1614
1615 t = self.theclass()
1616 self.assertEqual(t.isoformat(), "00:00:00")
1617 self.assertEqual(t.isoformat(), str(t))
1618
1619 t = self.theclass(microsecond=1)
1620 self.assertEqual(t.isoformat(), "00:00:00.000001")
1621 self.assertEqual(t.isoformat(), str(t))
1622
1623 t = self.theclass(microsecond=10)
1624 self.assertEqual(t.isoformat(), "00:00:00.000010")
1625 self.assertEqual(t.isoformat(), str(t))
1626
1627 t = self.theclass(microsecond=100)
1628 self.assertEqual(t.isoformat(), "00:00:00.000100")
1629 self.assertEqual(t.isoformat(), str(t))
1630
1631 t = self.theclass(microsecond=1000)
1632 self.assertEqual(t.isoformat(), "00:00:00.001000")
1633 self.assertEqual(t.isoformat(), str(t))
1634
1635 t = self.theclass(microsecond=10000)
1636 self.assertEqual(t.isoformat(), "00:00:00.010000")
1637 self.assertEqual(t.isoformat(), str(t))
1638
1639 t = self.theclass(microsecond=100000)
1640 self.assertEqual(t.isoformat(), "00:00:00.100000")
1641 self.assertEqual(t.isoformat(), str(t))
1642
1643 def test_strftime(self):
1644 t = self.theclass(1, 2, 3, 4)
1645 self.assertEqual(t.strftime('%H %M %S'), "01 02 03")
1646 # A naive object replaces %z and %Z with empty strings.
1647 self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")
1648
1649 def test_str(self):
1650 self.assertEqual(str(self.theclass(1, 2, 3, 4)), "01:02:03.000004")
1651 self.assertEqual(str(self.theclass(10, 2, 3, 4000)), "10:02:03.004000")
1652 self.assertEqual(str(self.theclass(0, 2, 3, 400000)), "00:02:03.400000")
1653 self.assertEqual(str(self.theclass(12, 2, 3, 0)), "12:02:03")
1654 self.assertEqual(str(self.theclass(23, 15, 0, 0)), "23:15:00")
1655
1656 def test_repr(self):
1657 name = 'datetime.' + self.theclass.__name__
1658 self.assertEqual(repr(self.theclass(1, 2, 3, 4)),
1659 "%s(1, 2, 3, 4)" % name)
1660 self.assertEqual(repr(self.theclass(10, 2, 3, 4000)),
1661 "%s(10, 2, 3, 4000)" % name)
1662 self.assertEqual(repr(self.theclass(0, 2, 3, 400000)),
1663 "%s(0, 2, 3, 400000)" % name)
1664 self.assertEqual(repr(self.theclass(12, 2, 3, 0)),
1665 "%s(12, 2, 3)" % name)
1666 self.assertEqual(repr(self.theclass(23, 15, 0, 0)),
1667 "%s(23, 15)" % name)
1668
1669 def test_resolution_info(self):
1670 self.assert_(isinstance(self.theclass.min, self.theclass))
1671 self.assert_(isinstance(self.theclass.max, self.theclass))
1672 self.assert_(isinstance(self.theclass.resolution, timedelta))
1673 self.assert_(self.theclass.max > self.theclass.min)
1674
1675 def test_pickling(self):
1676 args = 20, 59, 16, 64**2
1677 orig = self.theclass(*args)
1678 for pickler, unpickler, proto in pickle_choices:
1679 green = pickler.dumps(orig, proto)
1680 derived = unpickler.loads(green)
1681 self.assertEqual(orig, derived)
1682
1683 def test_bool(self):
1684 cls = self.theclass
1685 self.failUnless(cls(1))
1686 self.failUnless(cls(0, 1))
1687 self.failUnless(cls(0, 0, 1))
1688 self.failUnless(cls(0, 0, 0, 1))
1689 self.failUnless(not cls(0))
1690 self.failUnless(not cls())
1691
1692 def test_replace(self):
1693 cls = self.theclass
1694 args = [1, 2, 3, 4]
1695 base = cls(*args)
1696 self.assertEqual(base, base.replace())
1697
1698 i = 0
1699 for name, newval in (("hour", 5),
1700 ("minute", 6),
1701 ("second", 7),
1702 ("microsecond", 8)):
1703 newargs = args[:]
1704 newargs[i] = newval
1705 expected = cls(*newargs)
1706 got = base.replace(**{name: newval})
1707 self.assertEqual(expected, got)
1708 i += 1
1709
1710 # Out of bounds.
1711 base = cls(1)
1712 self.assertRaises(ValueError, base.replace, hour=24)
1713 self.assertRaises(ValueError, base.replace, minute=-1)
1714 self.assertRaises(ValueError, base.replace, second=100)
1715 self.assertRaises(ValueError, base.replace, microsecond=1000000)
1716
1717 def test_subclass_time(self):
1718
1719 class C(self.theclass):
1720 theAnswer = 42
1721
1722 def __new__(cls, *args, **kws):
1723 temp = kws.copy()
1724 extra = temp.pop('extra')
1725 result = self.theclass.__new__(cls, *args, **temp)
1726 result.extra = extra
1727 return result
1728
1729 def newmeth(self, start):
1730 return start + self.hour + self.second
1731
1732 args = 4, 5, 6
1733
1734 dt1 = self.theclass(*args)
1735 dt2 = C(*args, **{'extra': 7})
1736
1737 self.assertEqual(dt2.__class__, C)
1738 self.assertEqual(dt2.theAnswer, 42)
1739 self.assertEqual(dt2.extra, 7)
1740 self.assertEqual(dt1.isoformat(), dt2.isoformat())
1741 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)
1742
1743 # A mixin for classes with a tzinfo= argument. Subclasses must define
1744 # theclass as a class atribute, and theclass(1, 1, 1, tzinfo=whatever)
1745 # must be legit (which is true for time and datetime).
1746 class TZInfoBase(unittest.TestCase):
1747
1748 def test_argument_passing(self):
1749 cls = self.theclass
1750 # A datetime passes itself on, a time passes None.
1751 class introspective(tzinfo):
1752 def tzname(self, dt): return dt and "real" or "none"
1753 def utcoffset(self, dt):
1754 return timedelta(minutes = dt and 42 or -42)
1755 dst = utcoffset
1756
1757 obj = cls(1, 2, 3, tzinfo=introspective())
1758
1759 expected = cls is time and "none" or "real"
1760 self.assertEqual(obj.tzname(), expected)
1761
1762 expected = timedelta(minutes=(cls is time and -42 or 42))
1763 self.assertEqual(obj.utcoffset(), expected)
1764 self.assertEqual(obj.dst(), expected)
1765
1766 def test_bad_tzinfo_classes(self):
1767 cls = self.theclass
1768 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=12)
1769
1770 class NiceTry(object):
1771 def __init__(self): pass
1772 def utcoffset(self, dt): pass
1773 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=NiceTry)
1774
1775 class BetterTry(tzinfo):
1776 def __init__(self): pass
1777 def utcoffset(self, dt): pass
1778 b = BetterTry()
1779 t = cls(1, 1, 1, tzinfo=b)
1780 self.failUnless(t.tzinfo is b)
1781
1782 def test_utc_offset_out_of_bounds(self):
1783 class Edgy(tzinfo):
1784 def __init__(self, offset):
1785 self.offset = timedelta(minutes=offset)
1786 def utcoffset(self, dt):
1787 return self.offset
1788
1789 cls = self.theclass
1790 for offset, legit in ((-1440, False),
1791 (-1439, True),
1792 (1439, True),
1793 (1440, False)):
1794 if cls is time:
1795 t = cls(1, 2, 3, tzinfo=Edgy(offset))
1796 elif cls is datetime:
1797 t = cls(6, 6, 6, 1, 2, 3, tzinfo=Edgy(offset))
1798 else:
1799 assert 0, "impossible"
1800 if legit:
1801 aofs = abs(offset)
1802 h, m = divmod(aofs, 60)
1803 tag = "%c%02d:%02d" % (offset < 0 and '-' or '+', h, m)
1804 if isinstance(t, datetime):
1805 t = t.timetz()
1806 self.assertEqual(str(t), "01:02:03" + tag)
1807 else:
1808 self.assertRaises(ValueError, str, t)
1809
1810 def test_tzinfo_classes(self):
1811 cls = self.theclass
1812 class C1(tzinfo):
1813 def utcoffset(self, dt): return None
1814 def dst(self, dt): return None
1815 def tzname(self, dt): return None
1816 for t in (cls(1, 1, 1),
1817 cls(1, 1, 1, tzinfo=None),
1818 cls(1, 1, 1, tzinfo=C1())):
1819 self.failUnless(t.utcoffset() is None)
1820 self.failUnless(t.dst() is None)
1821 self.failUnless(t.tzname() is None)
1822
1823 class C3(tzinfo):
1824 def utcoffset(self, dt): return timedelta(minutes=-1439)
1825 def dst(self, dt): return timedelta(minutes=1439)
1826 def tzname(self, dt): return "aname"
1827 t = cls(1, 1, 1, tzinfo=C3())
1828 self.assertEqual(t.utcoffset(), timedelta(minutes=-1439))
1829 self.assertEqual(t.dst(), timedelta(minutes=1439))
1830 self.assertEqual(t.tzname(), "aname")
1831
1832 # Wrong types.
1833 class C4(tzinfo):
1834 def utcoffset(self, dt): return "aname"
1835 def dst(self, dt): return 7
1836 def tzname(self, dt): return 0
1837 t = cls(1, 1, 1, tzinfo=C4())
1838 self.assertRaises(TypeError, t.utcoffset)
1839 self.assertRaises(TypeError, t.dst)
1840 self.assertRaises(TypeError, t.tzname)
1841
1842 # Offset out of range.
1843 class C6(tzinfo):
1844 def utcoffset(self, dt): return timedelta(hours=-24)
1845 def dst(self, dt): return timedelta(hours=24)
1846 t = cls(1, 1, 1, tzinfo=C6())
1847 self.assertRaises(ValueError, t.utcoffset)
1848 self.assertRaises(ValueError, t.dst)
1849
1850 # Not a whole number of minutes.
1851 class C7(tzinfo):
1852 def utcoffset(self, dt): return timedelta(seconds=61)
1853 def dst(self, dt): return timedelta(microseconds=-81)
1854 t = cls(1, 1, 1, tzinfo=C7())
1855 self.assertRaises(ValueError, t.utcoffset)
1856 self.assertRaises(ValueError, t.dst)
1857
1858 def test_aware_compare(self):
1859 cls = self.theclass
1860
1861 # Ensure that utcoffset() gets ignored if the comparands have
1862 # the same tzinfo member.
1863 class OperandDependentOffset(tzinfo):
1864 def utcoffset(self, t):
1865 if t.minute < 10:
1866 # d0 and d1 equal after adjustment
1867 return timedelta(minutes=t.minute)
1868 else:
1869 # d2 off in the weeds
1870 return timedelta(minutes=59)
1871
1872 base = cls(8, 9, 10, tzinfo=OperandDependentOffset())
1873 d0 = base.replace(minute=3)
1874 d1 = base.replace(minute=9)
1875 d2 = base.replace(minute=11)
1876 for x in d0, d1, d2:
1877 for y in d0, d1, d2:
1878 got = cmp(x, y)
1879 expected = cmp(x.minute, y.minute)
1880 self.assertEqual(got, expected)
1881
1882 # However, if they're different members, uctoffset is not ignored.
1883 # Note that a time can't actually have an operand-depedent offset,
1884 # though (and time.utcoffset() passes None to tzinfo.utcoffset()),
1885 # so skip this test for time.
1886 if cls is not time:
1887 d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
1888 d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
1889 d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
1890 for x in d0, d1, d2:
1891 for y in d0, d1, d2:
1892 got = cmp(x, y)
1893 if (x is d0 or x is d1) and (y is d0 or y is d1):
1894 expected = 0
1895 elif x is y is d2:
1896 expected = 0
1897 elif x is d2:
1898 expected = -1
1899 else:
1900 assert y is d2
1901 expected = 1
1902 self.assertEqual(got, expected)
1903
1904
1905 # Testing time objects with a non-None tzinfo.
1906 class TestTimeTZ(TestTime, TZInfoBase):
1907 theclass = time
1908
1909 def test_empty(self):
1910 t = self.theclass()
1911 self.assertEqual(t.hour, 0)
1912 self.assertEqual(t.minute, 0)
1913 self.assertEqual(t.second, 0)
1914 self.assertEqual(t.microsecond, 0)
1915 self.failUnless(t.tzinfo is None)
1916
1917 def test_zones(self):
1918 est = FixedOffset(-300, "EST", 1)
1919 utc = FixedOffset(0, "UTC", -2)
1920 met = FixedOffset(60, "MET", 3)
1921 t1 = time( 7, 47, tzinfo=est)
1922 t2 = time(12, 47, tzinfo=utc)
1923 t3 = time(13, 47, tzinfo=met)
1924 t4 = time(microsecond=40)
1925 t5 = time(microsecond=40, tzinfo=utc)
1926
1927 self.assertEqual(t1.tzinfo, est)
1928 self.assertEqual(t2.tzinfo, utc)
1929 self.assertEqual(t3.tzinfo, met)
1930 self.failUnless(t4.tzinfo is None)
1931 self.assertEqual(t5.tzinfo, utc)
1932
1933 self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
1934 self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
1935 self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
1936 self.failUnless(t4.utcoffset() is None)
1937 self.assertRaises(TypeError, t1.utcoffset, "no args")
1938
1939 self.assertEqual(t1.tzname(), "EST")
1940 self.assertEqual(t2.tzname(), "UTC")
1941 self.assertEqual(t3.tzname(), "MET")
1942 self.failUnless(t4.tzname() is None)
1943 self.assertRaises(TypeError, t1.tzname, "no args")
1944
1945 self.assertEqual(t1.dst(), timedelta(minutes=1))
1946 self.assertEqual(t2.dst(), timedelta(minutes=-2))
1947 self.assertEqual(t3.dst(), timedelta(minutes=3))
1948 self.failUnless(t4.dst() is None)
1949 self.assertRaises(TypeError, t1.dst, "no args")
1950
1951 self.assertEqual(hash(t1), hash(t2))
1952 self.assertEqual(hash(t1), hash(t3))
1953 self.assertEqual(hash(t2), hash(t3))
1954
1955 self.assertEqual(t1, t2)
1956 self.assertEqual(t1, t3)
1957 self.assertEqual(t2, t3)
1958 self.assertRaises(TypeError, lambda: t4 == t5) # mixed tz-aware & naive
1959 self.assertRaises(TypeError, lambda: t4 < t5) # mixed tz-aware & naive
1960 self.assertRaises(TypeError, lambda: t5 < t4) # mixed tz-aware & naive
1961
1962 self.assertEqual(str(t1), "07:47:00-05:00")
1963 self.assertEqual(str(t2), "12:47:00+00:00")
1964 self.assertEqual(str(t3), "13:47:00+01:00")
1965 self.assertEqual(str(t4), "00:00:00.000040")
1966 self.assertEqual(str(t5), "00:00:00.000040+00:00")
1967
1968 self.assertEqual(t1.isoformat(), "07:47:00-05:00")
1969 self.assertEqual(t2.isoformat(), "12:47:00+00:00")
1970 self.assertEqual(t3.isoformat(), "13:47:00+01:00")
1971 self.assertEqual(t4.isoformat(), "00:00:00.000040")
1972 self.assertEqual(t5.isoformat(), "00:00:00.000040+00:00")
1973
1974 d = 'datetime.time'
1975 self.assertEqual(repr(t1), d + "(7, 47, tzinfo=est)")
1976 self.assertEqual(repr(t2), d + "(12, 47, tzinfo=utc)")
1977 self.assertEqual(repr(t3), d + "(13, 47, tzinfo=met)")
1978 self.assertEqual(repr(t4), d + "(0, 0, 0, 40)")
1979 self.assertEqual(repr(t5), d + "(0, 0, 0, 40, tzinfo=utc)")
1980
1981 self.assertEqual(t1.strftime("%H:%M:%S %%Z=%Z %%z=%z"),
1982 "07:47:00 %Z=EST %z=-0500")
1983 self.assertEqual(t2.strftime("%H:%M:%S %Z %z"), "12:47:00 UTC +0000")
1984 self.assertEqual(t3.strftime("%H:%M:%S %Z %z"), "13:47:00 MET +0100")
1985
1986 yuck = FixedOffset(-1439, "%z %Z %%z%%Z")
1987 t1 = time(23, 59, tzinfo=yuck)
1988 self.assertEqual(t1.strftime("%H:%M %%Z='%Z' %%z='%z'"),
1989 "23:59 %Z='%z %Z %%z%%Z' %z='-2359'")
1990
1991 # Check that an invalid tzname result raises an exception.
1992 class Badtzname(tzinfo):
1993 def tzname(self, dt): return 42
1994 t = time(2, 3, 4, tzinfo=Badtzname())
1995 self.assertEqual(t.strftime("%H:%M:%S"), "02:03:04")
1996 self.assertRaises(TypeError, t.strftime, "%Z")
1997
1998 def test_hash_edge_cases(self):
1999 # Offsets that overflow a basic time.
2000 t1 = self.theclass(0, 1, 2, 3, tzinfo=FixedOffset(1439, ""))
2001 t2 = self.theclass(0, 0, 2, 3, tzinfo=FixedOffset(1438, ""))
2002 self.assertEqual(hash(t1), hash(t2))
2003
2004 t1 = self.theclass(23, 58, 6, 100, tzinfo=FixedOffset(-1000, ""))
2005 t2 = self.theclass(23, 48, 6, 100, tzinfo=FixedOffset(-1010, ""))
2006 self.assertEqual(hash(t1), hash(t2))
2007
2008 def test_pickling(self):
2009 # Try one without a tzinfo.
2010 args = 20, 59, 16, 64**2
2011 orig = self.theclass(*args)
2012 for pickler, unpickler, proto in pickle_choices:
2013 green = pickler.dumps(orig, proto)
2014 derived = unpickler.loads(green)
2015 self.assertEqual(orig, derived)
2016
2017 # Try one with a tzinfo.
2018 tinfo = PicklableFixedOffset(-300, 'cookie')
2019 orig = self.theclass(5, 6, 7, tzinfo=tinfo)
2020 for pickler, unpickler, proto in pickle_choices:
2021 green = pickler.dumps(orig, proto)
2022 derived = unpickler.loads(green)
2023 self.assertEqual(orig, derived)
2024 self.failUnless(isinstance(derived.tzinfo, PicklableFixedOffset))
2025 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
2026 self.assertEqual(derived.tzname(), 'cookie')
2027
2028 def test_more_bool(self):
2029 # Test cases with non-None tzinfo.
2030 cls = self.theclass
2031
2032 t = cls(0, tzinfo=FixedOffset(-300, ""))
2033 self.failUnless(t)
2034
2035 t = cls(5, tzinfo=FixedOffset(-300, ""))
2036 self.failUnless(t)
2037
2038 t = cls(5, tzinfo=FixedOffset(300, ""))
2039 self.failUnless(not t)
2040
2041 t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))
2042 self.failUnless(not t)
2043
2044 # Mostly ensuring this doesn't overflow internally.
2045 t = cls(0, tzinfo=FixedOffset(23*60 + 59, ""))
2046 self.failUnless(t)
2047
2048 # But this should yield a value error -- the utcoffset is bogus.
2049 t = cls(0, tzinfo=FixedOffset(24*60, ""))
2050 self.assertRaises(ValueError, lambda: bool(t))
2051
2052 # Likewise.
2053 t = cls(0, tzinfo=FixedOffset(-24*60, ""))
2054 self.assertRaises(ValueError, lambda: bool(t))
2055
2056 def test_replace(self):
2057 cls = self.theclass
2058 z100 = FixedOffset(100, "+100")
2059 zm200 = FixedOffset(timedelta(minutes=-200), "-200")
2060 args = [1, 2, 3, 4, z100]
2061 base = cls(*args)
2062 self.assertEqual(base, base.replace())
2063
2064 i = 0
2065 for name, newval in (("hour", 5),
2066 ("minute", 6),
2067 ("second", 7),
2068 ("microsecond", 8),
2069 ("tzinfo", zm200)):
2070 newargs = args[:]
2071 newargs[i] = newval
2072 expected = cls(*newargs)
2073 got = base.replace(**{name: newval})
2074 self.assertEqual(expected, got)
2075 i += 1
2076
2077 # Ensure we can get rid of a tzinfo.
2078 self.assertEqual(base.tzname(), "+100")
2079 base2 = base.replace(tzinfo=None)
2080 self.failUnless(base2.tzinfo is None)
2081 self.failUnless(base2.tzname() is None)
2082
2083 # Ensure we can add one.
2084 base3 = base2.replace(tzinfo=z100)
2085 self.assertEqual(base, base3)
2086 self.failUnless(base.tzinfo is base3.tzinfo)
2087
2088 # Out of bounds.
2089 base = cls(1)
2090 self.assertRaises(ValueError, base.replace, hour=24)
2091 self.assertRaises(ValueError, base.replace, minute=-1)
2092 self.assertRaises(ValueError, base.replace, second=100)
2093 self.assertRaises(ValueError, base.replace, microsecond=1000000)
2094
2095 def test_mixed_compare(self):
2096 t1 = time(1, 2, 3)
2097 t2 = time(1, 2, 3)
2098 self.assertEqual(t1, t2)
2099 t2 = t2.replace(tzinfo=None)
2100 self.assertEqual(t1, t2)
2101 t2 = t2.replace(tzinfo=FixedOffset(None, ""))
2102 self.assertEqual(t1, t2)
2103 t2 = t2.replace(tzinfo=FixedOffset(0, ""))
2104 self.assertRaises(TypeError, lambda: t1 == t2)
2105
2106 # In time w/ identical tzinfo objects, utcoffset is ignored.
2107 class Varies(tzinfo):
2108 def __init__(self):
2109 self.offset = timedelta(minutes=22)
2110 def utcoffset(self, t):
2111 self.offset += timedelta(minutes=1)
2112 return self.offset
2113
2114 v = Varies()
2115 t1 = t2.replace(tzinfo=v)
2116 t2 = t2.replace(tzinfo=v)
2117 self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
2118 self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
2119 self.assertEqual(t1, t2)
2120
2121 # But if they're not identical, it isn't ignored.
2122 t2 = t2.replace(tzinfo=Varies())
2123 self.failUnless(t1 < t2) # t1's offset counter still going up
2124
2125 def test_subclass_timetz(self):
2126
2127 class C(self.theclass):
2128 theAnswer = 42
2129
2130 def __new__(cls, *args, **kws):
2131 temp = kws.copy()
2132 extra = temp.pop('extra')
2133 result = self.theclass.__new__(cls, *args, **temp)
2134 result.extra = extra
2135 return result
2136
2137 def newmeth(self, start):
2138 return start + self.hour + self.second
2139
2140 args = 4, 5, 6, 500, FixedOffset(-300, "EST", 1)
2141
2142 dt1 = self.theclass(*args)
2143 dt2 = C(*args, **{'extra': 7})
2144
2145 self.assertEqual(dt2.__class__, C)
2146 self.assertEqual(dt2.theAnswer, 42)
2147 self.assertEqual(dt2.extra, 7)
2148 self.assertEqual(dt1.utcoffset(), dt2.utcoffset())
2149 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)
2150
2151
2152 # Testing datetime objects with a non-None tzinfo.
2153
2154 class TestDateTimeTZ(TestDateTime, TZInfoBase):
2155 theclass = datetime
2156
2157 def test_trivial(self):
2158 dt = self.theclass(1, 2, 3, 4, 5, 6, 7)
2159 self.assertEqual(dt.year, 1)
2160 self.assertEqual(dt.month, 2)
2161 self.assertEqual(dt.day, 3)
2162 self.assertEqual(dt.hour, 4)
2163 self.assertEqual(dt.minute, 5)
2164 self.assertEqual(dt.second, 6)
2165 self.assertEqual(dt.microsecond, 7)
2166 self.assertEqual(dt.tzinfo, None)
2167
2168 def test_even_more_compare(self):
2169 # The test_compare() and test_more_compare() inherited from TestDate
2170 # and TestDateTime covered non-tzinfo cases.
2171
2172 # Smallest possible after UTC adjustment.
2173 t1 = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
2174 # Largest possible after UTC adjustment.
2175 t2 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
2176 tzinfo=FixedOffset(-1439, ""))
2177
2178 # Make sure those compare correctly, and w/o overflow.
2179 self.failUnless(t1 < t2)
2180 self.failUnless(t1 != t2)
2181 self.failUnless(t2 > t1)
2182
2183 self.failUnless(t1 == t1)
2184 self.failUnless(t2 == t2)
2185
2186 # Equal afer adjustment.
2187 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""))
2188 t2 = self.theclass(2, 1, 1, 3, 13, tzinfo=FixedOffset(3*60+13+2, ""))
2189 self.assertEqual(t1, t2)
2190
2191 # Change t1 not to subtract a minute, and t1 should be larger.
2192 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))
2193 self.failUnless(t1 > t2)
2194
2195 # Change t1 to subtract 2 minutes, and t1 should be smaller.
2196 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))
2197 self.failUnless(t1 < t2)
2198
2199 # Back to the original t1, but make seconds resolve it.
2200 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
2201 second=1)
2202 self.failUnless(t1 > t2)
2203
2204 # Likewise, but make microseconds resolve it.
2205 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
2206 microsecond=1)
2207 self.failUnless(t1 > t2)
2208
2209 # Make t2 naive and it should fail.
2210 t2 = self.theclass.min
2211 self.assertRaises(TypeError, lambda: t1 == t2)
2212 self.assertEqual(t2, t2)
2213
2214 # It's also naive if it has tzinfo but tzinfo.utcoffset() is None.
2215 class Naive(tzinfo):
2216 def utcoffset(self, dt): return None
2217 t2 = self.theclass(5, 6, 7, tzinfo=Naive())
2218 self.assertRaises(TypeError, lambda: t1 == t2)
2219 self.assertEqual(t2, t2)
2220
2221 # OTOH, it's OK to compare two of these mixing the two ways of being
2222 # naive.
2223 t1 = self.theclass(5, 6, 7)
2224 self.assertEqual(t1, t2)
2225
2226 # Try a bogus uctoffset.
2227 class Bogus(tzinfo):
2228 def utcoffset(self, dt):
2229 return timedelta(minutes=1440) # out of bounds
2230 t1 = self.theclass(2, 2, 2, tzinfo=Bogus())
2231 t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))
2232 self.assertRaises(ValueError, lambda: t1 == t2)
2233
2234 def test_pickling(self):
2235 # Try one without a tzinfo.
2236 args = 6, 7, 23, 20, 59, 1, 64**2
2237 orig = self.theclass(*args)
2238 for pickler, unpickler, proto in pickle_choices:
2239 green = pickler.dumps(orig, proto)
2240 derived = unpickler.loads(green)
2241 self.assertEqual(orig, derived)
2242
2243 # Try one with a tzinfo.
2244 tinfo = PicklableFixedOffset(-300, 'cookie')
2245 orig = self.theclass(*args, **{'tzinfo': tinfo})
2246 derived = self.theclass(1, 1, 1, tzinfo=FixedOffset(0, "", 0))
2247 for pickler, unpickler, proto in pickle_choices:
2248 green = pickler.dumps(orig, proto)
2249 derived = unpickler.loads(green)
2250 self.assertEqual(orig, derived)
2251 self.failUnless(isinstance(derived.tzinfo,
2252 PicklableFixedOffset))
2253 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
2254 self.assertEqual(derived.tzname(), 'cookie')
2255
2256 def test_extreme_hashes(self):
2257 # If an attempt is made to hash these via subtracting the offset
2258 # then hashing a datetime object, OverflowError results. The
2259 # Python implementation used to blow up here.
2260 t = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
2261 hash(t)
2262 t = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
2263 tzinfo=FixedOffset(-1439, ""))
2264 hash(t)
2265
2266 # OTOH, an OOB offset should blow up.
2267 t = self.theclass(5, 5, 5, tzinfo=FixedOffset(-1440, ""))
2268 self.assertRaises(ValueError, hash, t)
2269
2270 def test_zones(self):
2271 est = FixedOffset(-300, "EST")
2272 utc = FixedOffset(0, "UTC")
2273 met = FixedOffset(60, "MET")
2274 t1 = datetime(2002, 3, 19, 7, 47, tzinfo=est)
2275 t2 = datetime(2002, 3, 19, 12, 47, tzinfo=utc)
2276 t3 = datetime(2002, 3, 19, 13, 47, tzinfo=met)
2277 self.assertEqual(t1.tzinfo, est)
2278 self.assertEqual(t2.tzinfo, utc)
2279 self.assertEqual(t3.tzinfo, met)
2280 self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
2281 self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
2282 self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
2283 self.assertEqual(t1.tzname(), "EST")
2284 self.assertEqual(t2.tzname(), "UTC")
2285 self.assertEqual(t3.tzname(), "MET")
2286 self.assertEqual(hash(t1), hash(t2))
2287 self.assertEqual(hash(t1), hash(t3))
2288 self.assertEqual(hash(t2), hash(t3))
2289 self.assertEqual(t1, t2)
2290 self.assertEqual(t1, t3)
2291 self.assertEqual(t2, t3)
2292 self.assertEqual(str(t1), "2002-03-19 07:47:00-05:00")
2293 self.assertEqual(str(t2), "2002-03-19 12:47:00+00:00")
2294 self.assertEqual(str(t3), "2002-03-19 13:47:00+01:00")
2295 d = 'datetime.datetime(2002, 3, 19, '
2296 self.assertEqual(repr(t1), d + "7, 47, tzinfo=est)")
2297 self.assertEqual(repr(t2), d + "12, 47, tzinfo=utc)")
2298 self.assertEqual(repr(t3), d + "13, 47, tzinfo=met)")
2299
2300 def test_combine(self):
2301 met = FixedOffset(60, "MET")
2302 d = date(2002, 3, 4)
2303 tz = time(18, 45, 3, 1234, tzinfo=met)
2304 dt = datetime.combine(d, tz)
2305 self.assertEqual(dt, datetime(2002, 3, 4, 18, 45, 3, 1234,
2306 tzinfo=met))
2307
2308 def test_extract(self):
2309 met = FixedOffset(60, "MET")
2310 dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234, tzinfo=met)
2311 self.assertEqual(dt.date(), date(2002, 3, 4))
2312 self.assertEqual(dt.time(), time(18, 45, 3, 1234))
2313 self.assertEqual(dt.timetz(), time(18, 45, 3, 1234, tzinfo=met))
2314
2315 def test_tz_aware_arithmetic(self):
2316 import random
2317
2318 now = self.theclass.now()
2319 tz55 = FixedOffset(-330, "west 5:30")
2320 timeaware = now.time().replace(tzinfo=tz55)
2321 nowaware = self.theclass.combine(now.date(), timeaware)
2322 self.failUnless(nowaware.tzinfo is tz55)
2323 self.assertEqual(nowaware.timetz(), timeaware)
2324
2325 # Can't mix aware and non-aware.
2326 self.assertRaises(TypeError, lambda: now - nowaware)
2327 self.assertRaises(TypeError, lambda: nowaware - now)
2328
2329 # And adding datetime's doesn't make sense, aware or not.
2330 self.assertRaises(TypeError, lambda: now + nowaware)
2331 self.assertRaises(TypeError, lambda: nowaware + now)
2332 self.assertRaises(TypeError, lambda: nowaware + nowaware)
2333
2334 # Subtracting should yield 0.
2335 self.assertEqual(now - now, timedelta(0))
2336 self.assertEqual(nowaware - nowaware, timedelta(0))
2337
2338 # Adding a delta should preserve tzinfo.
2339 delta = timedelta(weeks=1, minutes=12, microseconds=5678)
2340 nowawareplus = nowaware + delta
2341 self.failUnless(nowaware.tzinfo is tz55)
2342 nowawareplus2 = delta + nowaware
2343 self.failUnless(nowawareplus2.tzinfo is tz55)
2344 self.assertEqual(nowawareplus, nowawareplus2)
2345
2346 # that - delta should be what we started with, and that - what we
2347 # started with should be delta.
2348 diff = nowawareplus - delta
2349 self.failUnless(diff.tzinfo is tz55)
2350 self.assertEqual(nowaware, diff)
2351 self.assertRaises(TypeError, lambda: delta - nowawareplus)
2352 self.assertEqual(nowawareplus - nowaware, delta)
2353
2354 # Make up a random timezone.
2355 tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone")
2356 # Attach it to nowawareplus.
2357 nowawareplus = nowawareplus.replace(tzinfo=tzr)
2358 self.failUnless(nowawareplus.tzinfo is tzr)
2359 # Make sure the difference takes the timezone adjustments into account.
2360 got = nowaware - nowawareplus
2361 # Expected: (nowaware base - nowaware offset) -
2362 # (nowawareplus base - nowawareplus offset) =
2363 # (nowaware base - nowawareplus base) +
2364 # (nowawareplus offset - nowaware offset) =
2365 # -delta + nowawareplus offset - nowaware offset
2366 expected = nowawareplus.utcoffset() - nowaware.utcoffset() - delta
2367 self.assertEqual(got, expected)
2368
2369 # Try max possible difference.
2370 min = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, "min"))
2371 max = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
2372 tzinfo=FixedOffset(-1439, "max"))
2373 maxdiff = max - min
2374 self.assertEqual(maxdiff, self.theclass.max - self.theclass.min +
2375 timedelta(minutes=2*1439))
2376
2377 def test_tzinfo_now(self):
2378 meth = self.theclass.now
2379 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
2380 base = meth()
2381 # Try with and without naming the keyword.
2382 off42 = FixedOffset(42, "42")
2383 another = meth(off42)
2384 again = meth(tz=off42)
2385 self.failUnless(another.tzinfo is again.tzinfo)
2386 self.assertEqual(another.utcoffset(), timedelta(minutes=42))
2387 # Bad argument with and w/o naming the keyword.
2388 self.assertRaises(TypeError, meth, 16)
2389 self.assertRaises(TypeError, meth, tzinfo=16)
2390 # Bad keyword name.
2391 self.assertRaises(TypeError, meth, tinfo=off42)
2392 # Too many args.
2393 self.assertRaises(TypeError, meth, off42, off42)
2394
2395 # We don't know which time zone we're in, and don't have a tzinfo
2396 # class to represent it, so seeing whether a tz argument actually
2397 # does a conversion is tricky.
2398 weirdtz = FixedOffset(timedelta(hours=15, minutes=58), "weirdtz", 0)
2399 utc = FixedOffset(0, "utc", 0)
2400 for dummy in range(3):
2401 now = datetime.now(weirdtz)
2402 self.failUnless(now.tzinfo is weirdtz)
2403 utcnow = datetime.utcnow().replace(tzinfo=utc)
2404 now2 = utcnow.astimezone(weirdtz)
2405 if abs(now - now2) < timedelta(seconds=30):
2406 break
2407 # Else the code is broken, or more than 30 seconds passed between
2408 # calls; assuming the latter, just try again.
2409 else:
2410 # Three strikes and we're out.
2411 self.fail("utcnow(), now(tz), or astimezone() may be broken")
2412
2413 def test_tzinfo_fromtimestamp(self):
2414 import time
2415 meth = self.theclass.fromtimestamp
2416 ts = time.time()
2417 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
2418 base = meth(ts)
2419 # Try with and without naming the keyword.
2420 off42 = FixedOffset(42, "42")
2421 another = meth(ts, off42)
2422 again = meth(ts, tz=off42)
2423 self.failUnless(another.tzinfo is again.tzinfo)
2424 self.assertEqual(another.utcoffset(), timedelta(minutes=42))
2425 # Bad argument with and w/o naming the keyword.
2426 self.assertRaises(TypeError, meth, ts, 16)
2427 self.assertRaises(TypeError, meth, ts, tzinfo=16)
2428 # Bad keyword name.
2429 self.assertRaises(TypeError, meth, ts, tinfo=off42)
2430 # Too many args.
2431 self.assertRaises(TypeError, meth, ts, off42, off42)
2432 # Too few args.
2433 self.assertRaises(TypeError, meth)
2434
2435 # Try to make sure tz= actually does some conversion.
2436 timestamp = 1000000000
2437 utcdatetime = datetime.utcfromtimestamp(timestamp)
2438 # In POSIX (epoch 1970), that's 2001-09-09 01:46:40 UTC, give or take.
2439 # But on some flavor of Mac, it's nowhere near that. So we can't have
2440 # any idea here what time that actually is, we can only test that
2441 # relative changes match.
2442 utcoffset = timedelta(hours=-15, minutes=39) # arbitrary, but not zero
2443 tz = FixedOffset(utcoffset, "tz", 0)
2444 expected = utcdatetime + utcoffset
2445 got = datetime.fromtimestamp(timestamp, tz)
2446 self.assertEqual(expected, got.replace(tzinfo=None))
2447
2448 def test_tzinfo_utcnow(self):
2449 meth = self.theclass.utcnow
2450 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
2451 base = meth()
2452 # Try with and without naming the keyword; for whatever reason,
2453 # utcnow() doesn't accept a tzinfo argument.
2454 off42 = FixedOffset(42, "42")
2455 self.assertRaises(TypeError, meth, off42)
2456 self.assertRaises(TypeError, meth, tzinfo=off42)
2457
2458 def test_tzinfo_utcfromtimestamp(self):
2459 import time
2460 meth = self.theclass.utcfromtimestamp
2461 ts = time.time()
2462 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
2463 base = meth(ts)
2464 # Try with and without naming the keyword; for whatever reason,
2465 # utcfromtimestamp() doesn't accept a tzinfo argument.
2466 off42 = FixedOffset(42, "42")
2467 self.assertRaises(TypeError, meth, ts, off42)
2468 self.assertRaises(TypeError, meth, ts, tzinfo=off42)
2469
2470 def test_tzinfo_timetuple(self):
2471 # TestDateTime tested most of this. datetime adds a twist to the
2472 # DST flag.
2473 class DST(tzinfo):
2474 def __init__(self, dstvalue):
2475 if isinstance(dstvalue, int):
2476 dstvalue = timedelta(minutes=dstvalue)
2477 self.dstvalue = dstvalue
2478 def dst(self, dt):
2479 return self.dstvalue
2480
2481 cls = self.theclass
2482 for dstvalue, flag in (-33, 1), (33, 1), (0, 0), (None, -1):
2483 d = cls(1, 1, 1, 10, 20, 30, 40, tzinfo=DST(dstvalue))
2484 t = d.timetuple()
2485 self.assertEqual(1, t.tm_year)
2486 self.assertEqual(1, t.tm_mon)
2487 self.assertEqual(1, t.tm_mday)
2488 self.assertEqual(10, t.tm_hour)
2489 self.assertEqual(20, t.tm_min)
2490 self.assertEqual(30, t.tm_sec)
2491 self.assertEqual(0, t.tm_wday)
2492 self.assertEqual(1, t.tm_yday)
2493 self.assertEqual(flag, t.tm_isdst)
2494
2495 # dst() returns wrong type.
2496 self.assertRaises(TypeError, cls(1, 1, 1, tzinfo=DST("x")).timetuple)
2497
2498 # dst() at the edge.
2499 self.assertEqual(cls(1,1,1, tzinfo=DST(1439)).timetuple().tm_isdst, 1)
2500 self.assertEqual(cls(1,1,1, tzinfo=DST(-1439)).timetuple().tm_isdst, 1)
2501
2502 # dst() out of range.
2503 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(1440)).timetuple)
2504 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(-1440)).timetuple)
2505
2506 def test_utctimetuple(self):
2507 class DST(tzinfo):
2508 def __init__(self, dstvalue):
2509 if isinstance(dstvalue, int):
2510 dstvalue = timedelta(minutes=dstvalue)
2511 self.dstvalue = dstvalue
2512 def dst(self, dt):
2513 return self.dstvalue
2514
2515 cls = self.theclass
2516 # This can't work: DST didn't implement utcoffset.
2517 self.assertRaises(NotImplementedError,
2518 cls(1, 1, 1, tzinfo=DST(0)).utcoffset)
2519
2520 class UOFS(DST):
2521 def __init__(self, uofs, dofs=None):
2522 DST.__init__(self, dofs)
2523 self.uofs = timedelta(minutes=uofs)
2524 def utcoffset(self, dt):
2525 return self.uofs
2526
2527 # Ensure tm_isdst is 0 regardless of what dst() says: DST is never
2528 # in effect for a UTC time.
2529 for dstvalue in -33, 33, 0, None:
2530 d = cls(1, 2, 3, 10, 20, 30, 40, tzinfo=UOFS(-53, dstvalue))
2531 t = d.utctimetuple()
2532 self.assertEqual(d.year, t.tm_year)
2533 self.assertEqual(d.month, t.tm_mon)
2534 self.assertEqual(d.day, t.tm_mday)
2535 self.assertEqual(11, t.tm_hour) # 20mm + 53mm = 1hn + 13mm
2536 self.assertEqual(13, t.tm_min)
2537 self.assertEqual(d.second, t.tm_sec)
2538 self.assertEqual(d.weekday(), t.tm_wday)
2539 self.assertEqual(d.toordinal() - date(1, 1, 1).toordinal() + 1,
2540 t.tm_yday)
2541 self.assertEqual(0, t.tm_isdst)
2542
2543 # At the edges, UTC adjustment can normalize into years out-of-range
2544 # for a datetime object. Ensure that a correct timetuple is
2545 # created anyway.
2546 tiny = cls(MINYEAR, 1, 1, 0, 0, 37, tzinfo=UOFS(1439))
2547 # That goes back 1 minute less than a full day.
2548 t = tiny.utctimetuple()
2549 self.assertEqual(t.tm_year, MINYEAR-1)
2550 self.assertEqual(t.tm_mon, 12)
2551 self.assertEqual(t.tm_mday, 31)
2552 self.assertEqual(t.tm_hour, 0)
2553 self.assertEqual(t.tm_min, 1)
2554 self.assertEqual(t.tm_sec, 37)
2555 self.assertEqual(t.tm_yday, 366) # "year 0" is a leap year
2556 self.assertEqual(t.tm_isdst, 0)
2557
2558 huge = cls(MAXYEAR, 12, 31, 23, 59, 37, 999999, tzinfo=UOFS(-1439))
2559 # That goes forward 1 minute less than a full day.
2560 t = huge.utctimetuple()
2561 self.assertEqual(t.tm_year, MAXYEAR+1)
2562 self.assertEqual(t.tm_mon, 1)
2563 self.assertEqual(t.tm_mday, 1)
2564 self.assertEqual(t.tm_hour, 23)
2565 self.assertEqual(t.tm_min, 58)
2566 self.assertEqual(t.tm_sec, 37)
2567 self.assertEqual(t.tm_yday, 1)
2568 self.assertEqual(t.tm_isdst, 0)
2569
2570 def test_tzinfo_isoformat(self):
2571 zero = FixedOffset(0, "+00:00")
2572 plus = FixedOffset(220, "+03:40")
2573 minus = FixedOffset(-231, "-03:51")
2574 unknown = FixedOffset(None, "")
2575
2576 cls = self.theclass
2577 datestr = '0001-02-03'
2578 for ofs in None, zero, plus, minus, unknown:
2579 for us in 0, 987001:
2580 d = cls(1, 2, 3, 4, 5, 59, us, tzinfo=ofs)
2581 timestr = '04:05:59' + (us and '.987001' or '')
2582 ofsstr = ofs is not None and d.tzname() or ''
2583 tailstr = timestr + ofsstr
2584 iso = d.isoformat()
2585 self.assertEqual(iso, datestr + 'T' + tailstr)
2586 self.assertEqual(iso, d.isoformat('T'))
2587 self.assertEqual(d.isoformat('k'), datestr + 'k' + tailstr)
2588 self.assertEqual(str(d), datestr + ' ' + tailstr)
2589
2590 def test_replace(self):
2591 cls = self.theclass
2592 z100 = FixedOffset(100, "+100")
2593 zm200 = FixedOffset(timedelta(minutes=-200), "-200")
2594 args = [1, 2, 3, 4, 5, 6, 7, z100]
2595 base = cls(*args)
2596 self.assertEqual(base, base.replace())
2597
2598 i = 0
2599 for name, newval in (("year", 2),
2600 ("month", 3),
2601 ("day", 4),
2602 ("hour", 5),
2603 ("minute", 6),
2604 ("second", 7),
2605 ("microsecond", 8),
2606 ("tzinfo", zm200)):
2607 newargs = args[:]
2608 newargs[i] = newval
2609 expected = cls(*newargs)
2610 got = base.replace(**{name: newval})
2611 self.assertEqual(expected, got)
2612 i += 1
2613
2614 # Ensure we can get rid of a tzinfo.
2615 self.assertEqual(base.tzname(), "+100")
2616 base2 = base.replace(tzinfo=None)
2617 self.failUnless(base2.tzinfo is None)
2618 self.failUnless(base2.tzname() is None)
2619
2620 # Ensure we can add one.
2621 base3 = base2.replace(tzinfo=z100)
2622 self.assertEqual(base, base3)
2623 self.failUnless(base.tzinfo is base3.tzinfo)
2624
2625 # Out of bounds.
2626 base = cls(2000, 2, 29)
2627 self.assertRaises(ValueError, base.replace, year=2001)
2628
2629 def test_more_astimezone(self):
2630 # The inherited test_astimezone covered some trivial and error cases.
2631 fnone = FixedOffset(None, "None")
2632 f44m = FixedOffset(44, "44")
2633 fm5h = FixedOffset(-timedelta(hours=5), "m300")
2634
2635 dt = self.theclass.now(tz=f44m)
2636 self.failUnless(dt.tzinfo is f44m)
2637 # Replacing with degenerate tzinfo raises an exception.
2638 self.assertRaises(ValueError, dt.astimezone, fnone)
2639 # Ditto with None tz.
2640 self.assertRaises(TypeError, dt.astimezone, None)
2641 # Replacing with same tzinfo makes no change.
2642 x = dt.astimezone(dt.tzinfo)
2643 self.failUnless(x.tzinfo is f44m)
2644 self.assertEqual(x.date(), dt.date())
2645 self.assertEqual(x.time(), dt.time())
2646
2647 # Replacing with different tzinfo does adjust.
2648 got = dt.astimezone(fm5h)
2649 self.failUnless(got.tzinfo is fm5h)
2650 self.assertEqual(got.utcoffset(), timedelta(hours=-5))
2651 expected = dt - dt.utcoffset() # in effect, convert to UTC
2652 expected += fm5h.utcoffset(dt) # and from there to local time
2653 expected = expected.replace(tzinfo=fm5h) # and attach new tzinfo
2654 self.assertEqual(got.date(), expected.date())
2655 self.assertEqual(got.time(), expected.time())
2656 self.assertEqual(got.timetz(), expected.timetz())
2657 self.failUnless(got.tzinfo is expected.tzinfo)
2658 self.assertEqual(got, expected)
2659
2660 def test_aware_subtract(self):
2661 cls = self.theclass
2662
2663 # Ensure that utcoffset() is ignored when the operands have the
2664 # same tzinfo member.
2665 class OperandDependentOffset(tzinfo):
2666 def utcoffset(self, t):
2667 if t.minute < 10:
2668 # d0 and d1 equal after adjustment
2669 return timedelta(minutes=t.minute)
2670 else:
2671 # d2 off in the weeds
2672 return timedelta(minutes=59)
2673
2674 base = cls(8, 9, 10, 11, 12, 13, 14, tzinfo=OperandDependentOffset())
2675 d0 = base.replace(minute=3)
2676 d1 = base.replace(minute=9)
2677 d2 = base.replace(minute=11)
2678 for x in d0, d1, d2:
2679 for y in d0, d1, d2:
2680 got = x - y
2681 expected = timedelta(minutes=x.minute - y.minute)
2682 self.assertEqual(got, expected)
2683
2684 # OTOH, if the tzinfo members are distinct, utcoffsets aren't
2685 # ignored.
2686 base = cls(8, 9, 10, 11, 12, 13, 14)
2687 d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
2688 d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
2689 d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
2690 for x in d0, d1, d2:
2691 for y in d0, d1, d2:
2692 got = x - y
2693 if (x is d0 or x is d1) and (y is d0 or y is d1):
2694 expected = timedelta(0)
2695 elif x is y is d2:
2696 expected = timedelta(0)
2697 elif x is d2:
2698 expected = timedelta(minutes=(11-59)-0)
2699 else:
2700 assert y is d2
2701 expected = timedelta(minutes=0-(11-59))
2702 self.assertEqual(got, expected)
2703
2704 def test_mixed_compare(self):
2705 t1 = datetime(1, 2, 3, 4, 5, 6, 7)
2706 t2 = datetime(1, 2, 3, 4, 5, 6, 7)
2707 self.assertEqual(t1, t2)
2708 t2 = t2.replace(tzinfo=None)
2709 self.assertEqual(t1, t2)
2710 t2 = t2.replace(tzinfo=FixedOffset(None, ""))
2711 self.assertEqual(t1, t2)
2712 t2 = t2.replace(tzinfo=FixedOffset(0, ""))
2713 self.assertRaises(TypeError, lambda: t1 == t2)
2714
2715 # In datetime w/ identical tzinfo objects, utcoffset is ignored.
2716 class Varies(tzinfo):
2717 def __init__(self):
2718 self.offset = timedelta(minutes=22)
2719 def utcoffset(self, t):
2720 self.offset += timedelta(minutes=1)
2721 return self.offset
2722
2723 v = Varies()
2724 t1 = t2.replace(tzinfo=v)
2725 t2 = t2.replace(tzinfo=v)
2726 self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
2727 self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
2728 self.assertEqual(t1, t2)
2729
2730 # But if they're not identical, it isn't ignored.
2731 t2 = t2.replace(tzinfo=Varies())
2732 self.failUnless(t1 < t2) # t1's offset counter still going up
2733
2734 def test_subclass_datetimetz(self):
2735
2736 class C(self.theclass):
2737 theAnswer = 42
2738
2739 def __new__(cls, *args, **kws):
2740 temp = kws.copy()
2741 extra = temp.pop('extra')
2742 result = self.theclass.__new__(cls, *args, **temp)
2743 result.extra = extra
2744 return result
2745
2746 def newmeth(self, start):
2747 return start + self.hour + self.year
2748
2749 args = 2002, 12, 31, 4, 5, 6, 500, FixedOffset(-300, "EST", 1)
2750
2751 dt1 = self.theclass(*args)
2752 dt2 = C(*args, **{'extra': 7})
2753
2754 self.assertEqual(dt2.__class__, C)
2755 self.assertEqual(dt2.theAnswer, 42)
2756 self.assertEqual(dt2.extra, 7)
2757 self.assertEqual(dt1.utcoffset(), dt2.utcoffset())
2758 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.year - 7)
2759
2760 # Pain to set up DST-aware tzinfo classes.
2761
2762 def first_sunday_on_or_after(dt):
2763 days_to_go = 6 - dt.weekday()
2764 if days_to_go:
2765 dt += timedelta(days_to_go)
2766 return dt
2767
2768 ZERO = timedelta(0)
2769 HOUR = timedelta(hours=1)
2770 DAY = timedelta(days=1)
2771 # In the US, DST starts at 2am (standard time) on the first Sunday in April.
2772 DSTSTART = datetime(1, 4, 1, 2)
2773 # and ends at 2am (DST time; 1am standard time) on the last Sunday of Oct,
2774 # which is the first Sunday on or after Oct 25. Because we view 1:MM as
2775 # being standard time on that day, there is no spelling in local time of
2776 # the last hour of DST (that's 1:MM DST, but 1:MM is taken as standard time).
2777 DSTEND = datetime(1, 10, 25, 1)
2778
2779 class USTimeZone(tzinfo):
2780
2781 def __init__(self, hours, reprname, stdname, dstname):
2782 self.stdoffset = timedelta(hours=hours)
2783 self.reprname = reprname
2784 self.stdname = stdname
2785 self.dstname = dstname
2786
2787 def __repr__(self):
2788 return self.reprname
2789
2790 def tzname(self, dt):
2791 if self.dst(dt):
2792 return self.dstname
2793 else:
2794 return self.stdname
2795
2796 def utcoffset(self, dt):
2797 return self.stdoffset + self.dst(dt)
2798
2799 def dst(self, dt):
2800 if dt is None or dt.tzinfo is None:
2801 # An exception instead may be sensible here, in one or more of
2802 # the cases.
2803 return ZERO
2804 assert dt.tzinfo is self
2805
2806 # Find first Sunday in April.
2807 start = first_sunday_on_or_after(DSTSTART.replace(year=dt.year))
2808 assert start.weekday() == 6 and start.month == 4 and start.day <= 7
2809
2810 # Find last Sunday in October.
2811 end = first_sunday_on_or_after(DSTEND.replace(year=dt.year))
2812 assert end.weekday() == 6 and end.month == 10 and end.day >= 25
2813
2814 # Can't compare naive to aware objects, so strip the timezone from
2815 # dt first.
2816 if start <= dt.replace(tzinfo=None) < end:
2817 return HOUR
2818 else:
2819 return ZERO
2820
2821 Eastern = USTimeZone(-5, "Eastern", "EST", "EDT")
2822 Central = USTimeZone(-6, "Central", "CST", "CDT")
2823 Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
2824 Pacific = USTimeZone(-8, "Pacific", "PST", "PDT")
2825 utc_real = FixedOffset(0, "UTC", 0)
2826 # For better test coverage, we want another flavor of UTC that's west of
2827 # the Eastern and Pacific timezones.
2828 utc_fake = FixedOffset(-12*60, "UTCfake", 0)
2829
2830 class TestTimezoneConversions(unittest.TestCase):
2831 # The DST switch times for 2002, in std time.
2832 dston = datetime(2002, 4, 7, 2)
2833 dstoff = datetime(2002, 10, 27, 1)
2834
2835 theclass = datetime
2836
2837 # Check a time that's inside DST.
2838 def checkinside(self, dt, tz, utc, dston, dstoff):
2839 self.assertEqual(dt.dst(), HOUR)
2840
2841 # Conversion to our own timezone is always an identity.
2842 self.assertEqual(dt.astimezone(tz), dt)
2843
2844 asutc = dt.astimezone(utc)
2845 there_and_back = asutc.astimezone(tz)
2846
2847 # Conversion to UTC and back isn't always an identity here,
2848 # because there are redundant spellings (in local time) of
2849 # UTC time when DST begins: the clock jumps from 1:59:59
2850 # to 3:00:00, and a local time of 2:MM:SS doesn't really
2851 # make sense then. The classes above treat 2:MM:SS as
2852 # daylight time then (it's "after 2am"), really an alias
2853 # for 1:MM:SS standard time. The latter form is what
2854 # conversion back from UTC produces.
2855 if dt.date() == dston.date() and dt.hour == 2:
2856 # We're in the redundant hour, and coming back from
2857 # UTC gives the 1:MM:SS standard-time spelling.
2858 self.assertEqual(there_and_back + HOUR, dt)
2859 # Although during was considered to be in daylight
2860 # time, there_and_back is not.
2861 self.assertEqual(there_and_back.dst(), ZERO)
2862 # They're the same times in UTC.
2863 self.assertEqual(there_and_back.astimezone(utc),
2864 dt.astimezone(utc))
2865 else:
2866 # We're not in the redundant hour.
2867 self.assertEqual(dt, there_and_back)
2868
2869 # Because we have a redundant spelling when DST begins, there is
2870 # (unforunately) an hour when DST ends that can't be spelled at all in
2871 # local time. When DST ends, the clock jumps from 1:59 back to 1:00
2872 # again. The hour 1:MM DST has no spelling then: 1:MM is taken to be
2873 # standard time. 1:MM DST == 0:MM EST, but 0:MM is taken to be
2874 # daylight time. The hour 1:MM daylight == 0:MM standard can't be
2875 # expressed in local time. Nevertheless, we want conversion back
2876 # from UTC to mimic the local clock's "repeat an hour" behavior.
2877 nexthour_utc = asutc + HOUR
2878 nexthour_tz = nexthour_utc.astimezone(tz)
2879 if dt.date() == dstoff.date() and dt.hour == 0:
2880 # We're in the hour before the last DST hour. The last DST hour
2881 # is ineffable. We want the conversion back to repeat 1:MM.
2882 self.assertEqual(nexthour_tz, dt.replace(hour=1))
2883 nexthour_utc += HOUR
2884 nexthour_tz = nexthour_utc.astimezone(tz)
2885 self.assertEqual(nexthour_tz, dt.replace(hour=1))
2886 else:
2887 self.assertEqual(nexthour_tz - dt, HOUR)
2888
2889 # Check a time that's outside DST.
2890 def checkoutside(self, dt, tz, utc):
2891 self.assertEqual(dt.dst(), ZERO)
2892
2893 # Conversion to our own timezone is always an identity.
2894 self.assertEqual(dt.astimezone(tz), dt)
2895
2896 # Converting to UTC and back is an identity too.
2897 asutc = dt.astimezone(utc)
2898 there_and_back = asutc.astimezone(tz)
2899 self.assertEqual(dt, there_and_back)
2900
2901 def convert_between_tz_and_utc(self, tz, utc):
2902 dston = self.dston.replace(tzinfo=tz)
2903 # Because 1:MM on the day DST ends is taken as being standard time,
2904 # there is no spelling in tz for the last hour of daylight time.
2905 # For purposes of the test, the last hour of DST is 0:MM, which is
2906 # taken as being daylight time (and 1:MM is taken as being standard
2907 # time).
2908 dstoff = self.dstoff.replace(tzinfo=tz)
2909 for delta in (timedelta(weeks=13),
2910 DAY,
2911 HOUR,
2912 timedelta(minutes=1),
2913 timedelta(microseconds=1)):
2914
2915 self.checkinside(dston, tz, utc, dston, dstoff)
2916 for during in dston + delta, dstoff - delta:
2917 self.checkinside(during, tz, utc, dston, dstoff)
2918
2919 self.checkoutside(dstoff, tz, utc)
2920 for outside in dston - delta, dstoff + delta:
2921 self.checkoutside(outside, tz, utc)
2922
2923 def test_easy(self):
2924 # Despite the name of this test, the endcases are excruciating.
2925 self.convert_between_tz_and_utc(Eastern, utc_real)
2926 self.convert_between_tz_and_utc(Pacific, utc_real)
2927 self.convert_between_tz_and_utc(Eastern, utc_fake)
2928 self.convert_between_tz_and_utc(Pacific, utc_fake)
2929 # The next is really dancing near the edge. It works because
2930 # Pacific and Eastern are far enough apart that their "problem
2931 # hours" don't overlap.
2932 self.convert_between_tz_and_utc(Eastern, Pacific)
2933 self.convert_between_tz_and_utc(Pacific, Eastern)
2934 # OTOH, these fail! Don't enable them. The difficulty is that
2935 # the edge case tests assume that every hour is representable in
2936 # the "utc" class. This is always true for a fixed-offset tzinfo
2937 # class (lke utc_real and utc_fake), but not for Eastern or Central.
2938 # For these adjacent DST-aware time zones, the range of time offsets
2939 # tested ends up creating hours in the one that aren't representable
2940 # in the other. For the same reason, we would see failures in the
2941 # Eastern vs Pacific tests too if we added 3*HOUR to the list of
2942 # offset deltas in convert_between_tz_and_utc().
2943 #
2944 # self.convert_between_tz_and_utc(Eastern, Central) # can't work
2945 # self.convert_between_tz_and_utc(Central, Eastern) # can't work
2946
2947 def test_tricky(self):
2948 # 22:00 on day before daylight starts.
2949 fourback = self.dston - timedelta(hours=4)
2950 ninewest = FixedOffset(-9*60, "-0900", 0)
2951 fourback = fourback.replace(tzinfo=ninewest)
2952 # 22:00-0900 is 7:00 UTC == 2:00 EST == 3:00 DST. Since it's "after
2953 # 2", we should get the 3 spelling.
2954 # If we plug 22:00 the day before into Eastern, it "looks like std
2955 # time", so its offset is returned as -5, and -5 - -9 = 4. Adding 4
2956 # to 22:00 lands on 2:00, which makes no sense in local time (the
2957 # local clock jumps from 1 to 3). The point here is to make sure we
2958 # get the 3 spelling.
2959 expected = self.dston.replace(hour=3)
2960 got = fourback.astimezone(Eastern).replace(tzinfo=None)
2961 self.assertEqual(expected, got)
2962
2963 # Similar, but map to 6:00 UTC == 1:00 EST == 2:00 DST. In that
2964 # case we want the 1:00 spelling.
2965 sixutc = self.dston.replace(hour=6, tzinfo=utc_real)
2966 # Now 6:00 "looks like daylight", so the offset wrt Eastern is -4,
2967 # and adding -4-0 == -4 gives the 2:00 spelling. We want the 1:00 EST
2968 # spelling.
2969 expected = self.dston.replace(hour=1)
2970 got = sixutc.astimezone(Eastern).replace(tzinfo=None)
2971 self.assertEqual(expected, got)
2972
2973 # Now on the day DST ends, we want "repeat an hour" behavior.
2974 # UTC 4:MM 5:MM 6:MM 7:MM checking these
2975 # EST 23:MM 0:MM 1:MM 2:MM
2976 # EDT 0:MM 1:MM 2:MM 3:MM
2977 # wall 0:MM 1:MM 1:MM 2:MM against these
2978 for utc in utc_real, utc_fake:
2979 for tz in Eastern, Pacific:
2980 first_std_hour = self.dstoff - timedelta(hours=2) # 23:MM
2981 # Convert that to UTC.
2982 first_std_hour -= tz.utcoffset(None)
2983 # Adjust for possibly fake UTC.
2984 asutc = first_std_hour + utc.utcoffset(None)
2985 # First UTC hour to convert; this is 4:00 when utc=utc_real &
2986 # tz=Eastern.
2987 asutcbase = asutc.replace(tzinfo=utc)
2988 for tzhour in (0, 1, 1, 2):
2989 expectedbase = self.dstoff.replace(hour=tzhour)
2990 for minute in 0, 30, 59:
2991 expected = expectedbase.replace(minute=minute)
2992 asutc = asutcbase.replace(minute=minute)
2993 astz = asutc.astimezone(tz)
2994 self.assertEqual(astz.replace(tzinfo=None), expected)
2995 asutcbase += HOUR
2996
2997
2998 def test_bogus_dst(self):
2999 class ok(tzinfo):
3000 def utcoffset(self, dt): return HOUR
3001 def dst(self, dt): return HOUR
3002
3003 now = self.theclass.now().replace(tzinfo=utc_real)
3004 # Doesn't blow up.
3005 now.astimezone(ok())
3006
3007 # Does blow up.
3008 class notok(ok):
3009 def dst(self, dt): return None
3010 self.assertRaises(ValueError, now.astimezone, notok())
3011
3012 def test_fromutc(self):
3013 self.assertRaises(TypeError, Eastern.fromutc) # not enough args
3014 now = datetime.utcnow().replace(tzinfo=utc_real)
3015 self.assertRaises(ValueError, Eastern.fromutc, now) # wrong tzinfo
3016 now = now.replace(tzinfo=Eastern) # insert correct tzinfo
3017 enow = Eastern.fromutc(now) # doesn't blow up
3018 self.assertEqual(enow.tzinfo, Eastern) # has right tzinfo member
3019 self.assertRaises(TypeError, Eastern.fromutc, now, now) # too many args
3020 self.assertRaises(TypeError, Eastern.fromutc, date.today()) # wrong type
3021
3022 # Always converts UTC to standard time.
3023 class FauxUSTimeZone(USTimeZone):
3024 def fromutc(self, dt):
3025 return dt + self.stdoffset
3026 FEastern = FauxUSTimeZone(-5, "FEastern", "FEST", "FEDT")
3027
3028 # UTC 4:MM 5:MM 6:MM 7:MM 8:MM 9:MM
3029 # EST 23:MM 0:MM 1:MM 2:MM 3:MM 4:MM
3030 # EDT 0:MM 1:MM 2:MM 3:MM 4:MM 5:MM
3031
3032 # Check around DST start.
3033 start = self.dston.replace(hour=4, tzinfo=Eastern)
3034 fstart = start.replace(tzinfo=FEastern)
3035 for wall in 23, 0, 1, 3, 4, 5:
3036 expected = start.replace(hour=wall)
3037 if wall == 23:
3038 expected -= timedelta(days=1)
3039 got = Eastern.fromutc(start)
3040 self.assertEqual(expected, got)
3041
3042 expected = fstart + FEastern.stdoffset
3043 got = FEastern.fromutc(fstart)
3044 self.assertEqual(expected, got)
3045
3046 # Ensure astimezone() calls fromutc() too.
3047 got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)
3048 self.assertEqual(expected, got)
3049
3050 start += HOUR
3051 fstart += HOUR
3052
3053 # Check around DST end.
3054 start = self.dstoff.replace(hour=4, tzinfo=Eastern)
3055 fstart = start.replace(tzinfo=FEastern)
3056 for wall in 0, 1, 1, 2, 3, 4:
3057 expected = start.replace(hour=wall)
3058 got = Eastern.fromutc(start)
3059 self.assertEqual(expected, got)
3060
3061 expected = fstart + FEastern.stdoffset
3062 got = FEastern.fromutc(fstart)
3063 self.assertEqual(expected, got)
3064
3065 # Ensure astimezone() calls fromutc() too.
3066 got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)
3067 self.assertEqual(expected, got)
3068
3069 start += HOUR
3070 fstart += HOUR
3071
3072
3073 def test_suite():
3074 allsuites = [unittest.makeSuite(klass, 'test')
3075 for klass in (TestModule,
3076 TestTZInfo,
3077 TestTimeDelta,
3078 TestDateOnly,
3079 TestDate,
3080 TestDateTime,
3081 TestTime,
3082 TestTimeTZ,
3083 TestDateTimeTZ,
3084 TestTimezoneConversions,
3085 )
3086 ]
3087 return unittest.TestSuite(allsuites)
3088
3089 def test_main():
3090 import gc
3091 import sys
3092
3093 thesuite = test_suite()
3094 lastrc = None
3095 while True:
3096 test_support.run_suite(thesuite)
3097 if 1: # change to 0, under a debug build, for some leak detection
3098 break
3099 gc.collect()
3100 if gc.garbage:
3101 raise SystemError("gc.garbage not empty after test run: %r" %
3102 gc.garbage)
3103 if hasattr(sys, 'gettotalrefcount'):
3104 thisrc = sys.gettotalrefcount()
3105 print >> sys.stderr, '*' * 10, 'total refs:', thisrc,
3106 if lastrc:
3107 print >> sys.stderr, 'delta:', thisrc - lastrc
3108 else:
3109 print >> sys.stderr
3110 lastrc = thisrc
3111
3112 if __name__ == "__main__":
3113 test_main()