Lines Matching refs:self
66 def test_constants(self):
68 self.assertEqual(datetime.MINYEAR, 1)
69 self.assertEqual(datetime.MAXYEAR, 9999)
71 def test_utc_alias(self):
72 self.assertIs(UTC, timezone.utc)
74 def test_all(self):
78 self.assertIn(attr, all_attrs)
80 def test_name_cleanup(self):
81 if '_Pure' in self.__class__.__name__:
82 self.skipTest('Only run for Fast C implementation')
90 self.assertEqual(names - allowed, set([]))
92 def test_divide_and_round(self):
93 if '_Fast' in self.__class__.__name__:
94 self.skipTest('Only run for Pure Python implementation')
98 self.assertEqual(dar(-10, -3), 3)
99 self.assertEqual(dar(5, -2), -2)
102 self.assertEqual(dar(7, 3), 2)
103 self.assertEqual(dar(-7, 3), -2)
104 self.assertEqual(dar(7, -3), -2)
105 self.assertEqual(dar(-7, -3), 2)
109 self.assertEqual(dar(10, 4), 2)
110 self.assertEqual(dar(-10, 4), -2)
111 self.assertEqual(dar(10, -4), -2)
112 self.assertEqual(dar(-10, -4), 2)
114 self.assertEqual(dar(6, 4), 2)
115 self.assertEqual(dar(-6, 4), -2)
116 self.assertEqual(dar(6, -4), -2)
117 self.assertEqual(dar(-6, -4), 2)
125 def __init__(self, offset, name, dstoffset=42):
130 self.__offset = offset
131 self.__name = name
132 self.__dstoffset = dstoffset
133 def __repr__(self):
134 return self.__name.lower()
135 def utcoffset(self, dt):
136 return self.__offset
137 def tzname(self, dt):
138 return self.__name
139 def dst(self, dt):
140 return self.__dstoffset
144 def __init__(self, offset=None, name=None, dstoffset=None):
145 FixedOffset.__init__(self, offset, name, dstoffset)
151 def utcoffset(self, datetime_module):
156 def test_refcnt_crash_bug_22044(self):
159 with self.assertRaises(TypeError):
162 def test_non_abstractness(self):
168 self.assertRaises(NotImplementedError, useless.tzname, dt)
169 self.assertRaises(NotImplementedError, useless.utcoffset, dt)
170 self.assertRaises(NotImplementedError, useless.dst, dt)
172 def test_subclass_must_override(self):
174 def __init__(self, offset, name):
175 self.__offset = offset
176 self.__name = name
177 self.assertTrue(issubclass(NotEnough, tzinfo))
179 self.assertIsInstance(ne, tzinfo)
182 self.assertRaises(NotImplementedError, ne.tzname, dt)
183 self.assertRaises(NotImplementedError, ne.utcoffset, dt)
184 self.assertRaises(NotImplementedError, ne.dst, dt)
186 def test_normal(self):
188 self.assertIsInstance(fo, tzinfo)
190 self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))
191 self.assertEqual(fo.tzname(dt), "Three")
192 self.assertEqual(fo.dst(dt), timedelta(minutes=42))
194 def test_pickling_base(self):
199 self.assertIs(type(orig), tzinfo)
203 self.assertIs(type(derived), tzinfo)
205 def test_pickling_subclass(self):
215 self.assertIsInstance(orig, tzinfo)
216 self.assertIs(type(orig), otype)
217 self.assertEqual(orig.utcoffset(None), offset)
218 self.assertEqual(orig.tzname(None), oname)
222 self.assertIsInstance(derived, tzinfo)
223 self.assertIs(type(derived), otype)
224 self.assertEqual(derived.utcoffset(None), offset)
225 self.assertEqual(derived.tzname(None), oname)
226 self.assertFalse(hasattr(derived, 'spam'))
228 def test_issue23600(self):
236 def utcoffset(self, dt):
239 def dst(self, dt):
242 def tzname(self, dt):
248 self.assertEqual(t - t.utcoffset(), u)
253 def setUp(self):
254 self.ACDT = timezone(timedelta(hours=9.5), 'ACDT')
255 self.EST = timezone(-timedelta(hours=5), 'EST')
256 self.DT = datetime(2010, 1, 1)
258 def test_str(self):
259 for tz in [self.ACDT, self.EST, timezone.utc,
261 self.assertEqual(str(tz), tz.tzname(None))
263 def test_repr(self):
265 for tz in [self.ACDT, self.EST, timezone.utc,
269 self.assertEqual(tz, eval(tzrep))
271 def test_class_members(self):
273 self.assertEqual(timezone.utc.utcoffset(None), ZERO)
274 self.assertEqual(timezone.min.utcoffset(None), -limit)
275 self.assertEqual(timezone.max.utcoffset(None), limit)
277 def test_constructor(self):
278 self.assertIs(timezone.utc, timezone(timedelta(0)))
279 self.assertIsNot(timezone.utc, timezone(timedelta(0), 'UTC'))
280 self.assertEqual(timezone.utc, timezone(timedelta(0), 'UTC'))
283 self.assertNotEqual(tz.utcoffset(None) % timedelta(minutes=1), 0)
286 self.assertRaises(ValueError, timezone, invalid)
287 self.assertRaises(ValueError, timezone, -invalid)
289 with self.assertRaises(TypeError): timezone(None)
290 with self.assertRaises(TypeError): timezone(42)
291 with self.assertRaises(TypeError): timezone(ZERO, None)
292 with self.assertRaises(TypeError): timezone(ZERO, 42)
293 with self.assertRaises(TypeError): timezone(ZERO, 'ABC', 'extra')
295 def test_inheritance(self):
296 self.assertIsInstance(timezone.utc, tzinfo)
297 self.assertIsInstance(self.EST, tzinfo)
299 def test_utcoffset(self):
300 dummy = self.DT
303 self.assertEqual(offset, timezone(offset).utcoffset(dummy))
304 self.assertEqual(-offset, timezone(-offset).utcoffset(dummy))
306 with self.assertRaises(TypeError): self.EST.utcoffset('')
307 with self.assertRaises(TypeError): self.EST.utcoffset(5)
310 def test_dst(self):
311 self.assertIsNone(timezone.utc.dst(self.DT))
313 with self.assertRaises(TypeError): self.EST.dst('')
314 with self.assertRaises(TypeError): self.EST.dst(5)
316 def test_tzname(self):
317 self.assertEqual('UTC', timezone.utc.tzname(None))
318 self.assertEqual('UTC', UTC.tzname(None))
319 self.assertEqual('UTC', timezone(ZERO).tzname(None))
320 self.assertEqual('UTC-05:00', timezone(-5 * HOUR).tzname(None))
321 self.assertEqual('UTC+09:30', timezone(9.5 * HOUR).tzname(None))
322 self.assertEqual('UTC-00:01', timezone(timedelta(minutes=-1)).tzname(None))
323 self.assertEqual('XYZ', timezone(-5 * HOUR, 'XYZ').tzname(None))
325 self.assertEqual('\ud800', timezone(ZERO, '\ud800').tzname(None))
328 self.assertEqual('UTC+01:06:40', timezone(timedelta(0, 4000)).tzname(None))
329 self.assertEqual('UTC-01:06:40',
331 self.assertEqual('UTC+01:06:40.000001',
333 self.assertEqual('UTC-01:06:40.000001',
336 with self.assertRaises(TypeError): self.EST.tzname('')
337 with self.assertRaises(TypeError): self.EST.tzname(5)
339 def test_fromutc(self):
340 with self.assertRaises(ValueError):
341 timezone.utc.fromutc(self.DT)
342 with self.assertRaises(TypeError):
344 for tz in [self.EST, self.ACDT, Eastern]:
345 utctime = self.DT.replace(tzinfo=tz)
347 self.assertEqual(local - utctime, tz.utcoffset(local))
348 self.assertEqual(local,
349 self.DT.replace(tzinfo=timezone.utc))
351 def test_comparison(self):
352 self.assertNotEqual(timezone(ZERO), timezone(HOUR))
353 self.assertEqual(timezone(HOUR), timezone(HOUR))
354 self.assertEqual(timezone(-5 * HOUR), timezone(-5 * HOUR, 'EST'))
355 with self.assertRaises(TypeError): timezone(ZERO) < timezone(ZERO)
356 self.assertIn(timezone(ZERO), {timezone(ZERO)})
357 self.assertTrue(timezone(ZERO) != None)
358 self.assertFalse(timezone(ZERO) == None)
361 self.assertTrue(tz == ALWAYS_EQ)
362 self.assertFalse(tz != ALWAYS_EQ)
363 self.assertTrue(tz < LARGEST)
364 self.assertFalse(tz > LARGEST)
365 self.assertTrue(tz <= LARGEST)
366 self.assertFalse(tz >= LARGEST)
367 self.assertFalse(tz < SMALLEST)
368 self.assertTrue(tz > SMALLEST)
369 self.assertFalse(tz <= SMALLEST)
370 self.assertTrue(tz >= SMALLEST)
372 def test_aware_datetime(self):
376 self.assertEqual(tz.tzname(t),
378 self.assertEqual(tz.utcoffset(t),
380 self.assertEqual(tz.dst(t),
383 def test_pickle(self):
384 for tz in self.ACDT, self.EST, timezone.min, timezone.max:
387 self.assertEqual(tz_copy, tz)
391 self.assertIs(tz_copy, tz)
393 def test_copy(self):
394 for tz in self.ACDT, self.EST, timezone.min, timezone.max:
396 self.assertEqual(tz_copy, tz)
399 self.assertIs(tz_copy, tz)
401 def test_deepcopy(self):
402 for tz in self.ACDT, self.EST, timezone.min, timezone.max:
404 self.assertEqual(tz_copy, tz)
407 self.assertIs(tz_copy, tz)
409 def test_offset_boundaries(self):
419 with self.subTest(test_type='good', delta=delta):
430 with self.subTest(test_type='bad', delta=delta):
431 with self.assertRaises(ValueError):
434 def test_comparison_with_tzinfo(self):
437 self.assertNotEqual(timezone.utc, tzinfo())
438 self.assertNotEqual(timezone(timedelta(hours=1)), tzinfo())
450 def test_harmless_mixed_comparison(self):
451 me = self.theclass(1, 1, 1)
453 self.assertFalse(me == ())
454 self.assertTrue(me != ())
455 self.assertFalse(() == me)
456 self.assertTrue(() != me)
458 self.assertIn(me, [1, 20, [], me])
459 self.assertIn([], [me, 1, 20, []])
465 self.assertTrue(me == ALWAYS_EQ)
466 self.assertFalse(me != ALWAYS_EQ)
470 self.assertTrue(me < LARGEST)
471 self.assertFalse(me > LARGEST)
472 self.assertTrue(me <= LARGEST)
473 self.assertFalse(me >= LARGEST)
474 self.assertFalse(me < SMALLEST)
475 self.assertTrue(me > SMALLEST)
476 self.assertFalse(me <= SMALLEST)
477 self.assertTrue(me >= SMALLEST)
479 def test_harmful_mixed_comparison(self):
480 me = self.theclass(1, 1, 1)
482 self.assertRaises(TypeError, lambda: me < ())
483 self.assertRaises(TypeError, lambda: me <= ())
484 self.assertRaises(TypeError, lambda: me > ())
485 self.assertRaises(TypeError, lambda: me >= ())
487 self.assertRaises(TypeError, lambda: () < me)
488 self.assertRaises(TypeError, lambda: () <= me)
489 self.assertRaises(TypeError, lambda: () > me)
490 self.assertRaises(TypeError, lambda: () >= me)
499 def test_constructor(self):
500 eq = self.assertEqual
524 def test_computations(self):
525 eq = self.assertEqual
607 def test_disallowed_computations(self):
612 self.assertRaises(TypeError, lambda: a+i)
613 self.assertRaises(TypeError, lambda: a-i)
614 self.assertRaises(TypeError, lambda: i+a)
615 self.assertRaises(TypeError, lambda: i-a)
620 self.assertRaises(TypeError, lambda: zero // a)
621 self.assertRaises(ZeroDivisionError, lambda: a // zero)
622 self.assertRaises(ZeroDivisionError, lambda: a / zero)
623 self.assertRaises(ZeroDivisionError, lambda: a / 0.0)
624 self.assertRaises(TypeError, lambda: a / '')
627 def test_disallowed_special(self):
629 self.assertRaises(ValueError, a.__mul__, NAN)
630 self.assertRaises(ValueError, a.__truediv__, NAN)
632 def test_basic_attributes(self):
635 self.assertEqual(td.days, days)
636 self.assertEqual(td.seconds, seconds)
637 self.assertEqual(td.microseconds, us)
639 def test_total_seconds(self):
641 self.assertEqual(td.total_seconds(), 31536000.0)
644 self.assertEqual(td.total_seconds(), total_seconds)
649 self.assertEqual(td.total_seconds(), td / timedelta(seconds=1))
651 def test_carries(self):
659 self.assertEqual(t1, t2)
661 def test_hash_equality(self):
669 self.assertEqual(hash(t1), hash(t2))
673 self.assertEqual(t1, t2)
674 self.assertEqual(hash(t1), hash(t2))
678 self.assertEqual(len(d), 1)
679 self.assertEqual(d[t1], 2)
681 def test_pickling(self):
687 self.assertEqual(orig, derived)
689 def test_compare(self):
692 self.assertEqual(t1, t2)
693 self.assertTrue(t1 <= t2)
694 self.assertTrue(t1 >= t2)
695 self.assertFalse(t1 != t2)
696 self.assertFalse(t1 < t2)
697 self.assertFalse(t1 > t2)
701 self.assertTrue(t1 < t2)
702 self.assertTrue(t2 > t1)
703 self.assertTrue(t1 <= t2)
704 self.assertTrue(t2 >= t1)
705 self.assertTrue(t1 != t2)
706 self.assertTrue(t2 != t1)
707 self.assertFalse(t1 == t2)
708 self.assertFalse(t2 == t1)
709 self.assertFalse(t1 > t2)
710 self.assertFalse(t2 < t1)
711 self.assertFalse(t1 >= t2)
712 self.assertFalse(t2 <= t1)
715 self.assertEqual(t1 == badarg, False)
716 self.assertEqual(t1 != badarg, True)
717 self.assertEqual(badarg == t1, False)
718 self.assertEqual(badarg != t1, True)
720 self.assertRaises(TypeError, lambda: t1 <= badarg)
721 self.assertRaises(TypeError, lambda: t1 < badarg)
722 self.assertRaises(TypeError, lambda: t1 > badarg)
723 self.assertRaises(TypeError, lambda: t1 >= badarg)
724 self.assertRaises(TypeError, lambda: badarg <= t1)
725 self.assertRaises(TypeError, lambda: badarg < t1)
726 self.assertRaises(TypeError, lambda: badarg > t1)
727 self.assertRaises(TypeError, lambda: badarg >= t1)
729 def test_str(self):
731 eq = self.assertEqual
750 def test_repr(self):
751 name = 'datetime.' + self.theclass.__name__
752 self.assertEqual(repr(self.theclass(1)),
754 self.assertEqual(repr(self.theclass(10, 2)),
756 self.assertEqual(repr(self.theclass(-10, 2, 400000)),
758 self.assertEqual(repr(self.theclass(seconds=60)),
760 self.assertEqual(repr(self.theclass()),
762 self.assertEqual(repr(self.theclass(microseconds=100)),
764 self.assertEqual(repr(self.theclass(days=1, microseconds=100)),
766 self.assertEqual(repr(self.theclass(seconds=1, microseconds=100)),
769 def test_roundtrip(self):
778 self.assertTrue(s.startswith('datetime.'))
781 self.assertEqual(td, td2)
785 self.assertEqual(td, td2)
787 def test_resolution_info(self):
788 self.assertIsInstance(timedelta.min, timedelta)
789 self.assertIsInstance(timedelta.max, timedelta)
790 self.assertIsInstance(timedelta.resolution, timedelta)
791 self.assertTrue(timedelta.max > timedelta.min)
792 self.assertEqual(timedelta.min, timedelta(-999999999))
793 self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))
794 self.assertEqual(timedelta.resolution, timedelta(0, 0, 1))
796 def test_overflow(self):
801 self.assertRaises(OverflowError, td.__sub__, tiny)
802 self.assertRaises(OverflowError, td.__add__, -tiny)
806 self.assertRaises(OverflowError, td.__add__, tiny)
807 self.assertRaises(OverflowError, td.__sub__, -tiny)
809 self.assertRaises(OverflowError, lambda: -timedelta.max)
812 self.assertRaises(OverflowError, day.__mul__, 10**9)
813 self.assertRaises(OverflowError, day.__mul__, 1e9)
814 self.assertRaises(OverflowError, day.__truediv__, 1e-20)
815 self.assertRaises(OverflowError, day.__truediv__, 1e-10)
816 self.assertRaises(OverflowError, day.__truediv__, 9e-10)
819 def _test_overflow_special(self):
821 self.assertRaises(OverflowError, day.__mul__, INF)
822 self.assertRaises(OverflowError, day.__mul__, -INF)
824 def test_microsecond_rounding(self):
826 eq = self.assertEqual
857 def test_massive_normalization(self):
859 self.assertEqual((td.days, td.seconds, td.microseconds),
862 def test_bool(self):
863 self.assertTrue(timedelta(1))
864 self.assertTrue(timedelta(0, 1))
865 self.assertTrue(timedelta(0, 0, 1))
866 self.assertTrue(timedelta(microseconds=1))
867 self.assertFalse(timedelta(0))
869 def test_subclass_timedelta(self):
876 def as_hours(self):
877 sum = (self.days * 24 +
878 self.seconds / 3600.0 +
879 self.microseconds / 3600e6)
883 self.assertIs(type(t1), T)
884 self.assertEqual(t1.as_hours(), 24)
887 self.assertIs(type(t2), T)
888 self.assertEqual(t2.as_hours(), -25)
891 self.assertIs(type(t3), timedelta)
893 self.assertIs(type(t4), T)
894 self.assertEqual(t3.days, t4.days)
895 self.assertEqual(t3.seconds, t4.seconds)
896 self.assertEqual(t3.microseconds, t4.microseconds)
897 self.assertEqual(str(t3), str(t4))
898 self.assertEqual(t4.as_hours(), -1)
900 def test_subclass_date(self):
914 with self.subTest(name):
916 self.assertEqual(act, expected)
917 self.assertIsInstance(act, DateSubclass)
919 def test_subclass_datetime(self):
933 with self.subTest(name):
935 self.assertEqual(act, expected)
936 self.assertIsInstance(act, DateTimeSubclass)
938 def test_division(self):
941 self.assertEqual(t / second, 5059.0)
942 self.assertEqual(t // second, 5059)
946 self.assertEqual(t / minute, 2.5)
947 self.assertEqual(t // minute, 2)
950 self.assertRaises(ZeroDivisionError, truediv, t, zerotd)
951 self.assertRaises(ZeroDivisionError, floordiv, t, zerotd)
953 # self.assertRaises(TypeError, truediv, t, 2)
957 def test_remainder(self):
961 self.assertEqual(r, timedelta(seconds=30))
965 self.assertEqual(r, timedelta(seconds=30))
968 self.assertRaises(ZeroDivisionError, mod, t, zerotd)
970 self.assertRaises(TypeError, mod, t, 10)
972 def test_divmod(self):
976 self.assertEqual(q, 2)
977 self.assertEqual(r, timedelta(seconds=30))
981 self.assertEqual(q, -2)
982 self.assertEqual(r, timedelta(seconds=30))
985 self.assertRaises(ZeroDivisionError, divmod, t, zerotd)
987 self.assertRaises(TypeError, divmod, t, 10)
989 def test_issue31293(self):
994 def as_integer_ratio(self):
998 with self.assertRaises(TypeError):
1000 with self.assertRaises(TypeError):
1004 with self.assertRaises(ValueError):
1006 with self.assertRaises(ValueError):
1009 def test_issue31752(self):
1013 def __mul__(self, other):
1015 def __rmul__(self, other):
1017 def __floordiv__(self, other):
1019 def __rfloordiv__(self, other):
1023 def __add__(self, other):
1025 def __radd__(self, other):
1029 def __divmod__(self, other):
1033 with self.subTest(divmodresult=divmodresult):
1068 def test_delta_non_days_ignored(self):
1073 self.assertEqual(days, timedelta(1))
1076 self.assertEqual(dt2, dt + days)
1079 self.assertEqual(dt2, dt + days)
1082 self.assertEqual(dt2, dt - days)
1086 self.assertEqual(days, timedelta(-2))
1089 self.assertEqual(dt2, dt + days)
1092 self.assertEqual(dt2, dt + days)
1095 self.assertEqual(dt2, dt - days)
1106 def test_basic_attributes(self):
1107 dt = self.theclass(2002, 3, 1)
1108 self.assertEqual(dt.year, 2002)
1109 self.assertEqual(dt.month, 3)
1110 self.assertEqual(dt.day, 1)
1112 def test_roundtrip(self):
1113 for dt in (self.theclass(1, 2, 3),
1114 self.theclass.today()):
1117 self.assertTrue(s.startswith('datetime.'))
1120 self.assertEqual(dt, dt2)
1123 dt2 = self.theclass(dt.year, dt.month, dt.day)
1124 self.assertEqual(dt, dt2)
1126 def test_ordinal_conversions(self):
1133 d = self.theclass(y, m, d)
1134 self.assertEqual(n, d.toordinal())
1135 fromord = self.theclass.fromordinal(n)
1136 self.assertEqual(d, fromord)
1140 self.assertEqual(fromord.hour, 0)
1141 self.assertEqual(fromord.minute, 0)
1142 self.assertEqual(fromord.second, 0)
1143 self.assertEqual(fromord.microsecond, 0)
1149 d = self.theclass(year, 1, 1)
1151 d2 = self.theclass.fromordinal(n)
1152 self.assertEqual(d, d2)
1155 d = self.theclass.fromordinal(n-1)
1156 d2 = self.theclass(year-1, 12, 31)
1157 self.assertEqual(d, d2)
1158 self.assertEqual(d2.toordinal(), n-1)
1163 n = self.theclass(year, 1, 1).toordinal()
1168 d = self.theclass(year, month, day)
1169 self.assertEqual(d.toordinal(), n)
1170 self.assertEqual(d, self.theclass.fromordinal(n))
1173 def test_extreme_ordinals(self):
1174 a = self.theclass.min
1175 a = self.theclass(a.year, a.month, a.day) # get rid of time parts
1178 self.assertEqual(a, b)
1180 self.assertRaises(ValueError, lambda: a.fromordinal(aord - 1))
1183 self.assertEqual(b.toordinal(), aord + 1)
1184 self.assertEqual(b, self.theclass.fromordinal(aord + 1))
1186 a = self.theclass.max
1187 a = self.theclass(a.year, a.month, a.day) # get rid of time parts
1190 self.assertEqual(a, b)
1192 self.assertRaises(ValueError, lambda: a.fromordinal(aord + 1))
1195 self.assertEqual(b.toordinal(), aord - 1)
1196 self.assertEqual(b, self.theclass.fromordinal(aord - 1))
1198 def test_bad_constructor_arguments(self):
1200 self.theclass(MINYEAR, 1, 1) # no exception
1201 self.theclass(MAXYEAR, 1, 1) # no exception
1202 self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)
1203 self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)
1205 self.theclass(2000, 1, 1) # no exception
1206 self.theclass(2000, 12, 1) # no exception
1207 self.assertRaises(ValueError, self.theclass, 2000, 0, 1)
1208 self.assertRaises(ValueError, self.theclass, 2000, 13, 1)
1210 self.theclass(2000, 2, 29) # no exception
1211 self.theclass(2004, 2, 29) # no exception
1212 self.theclass(2400, 2, 29) # no exception
1213 self.assertRaises(ValueError, self.theclass, 2000, 2, 30)
1214 self.assertRaises(ValueError, self.theclass, 2001, 2, 29)
1215 self.assertRaises(ValueError, self.theclass, 2100, 2, 29)
1216 self.assertRaises(ValueError, self.theclass, 1900, 2, 29)
1217 self.assertRaises(ValueError, self.theclass, 2000, 1, 0)
1218 self.assertRaises(ValueError, self.theclass, 2000, 1, 32)
1220 def test_hash_equality(self):
1221 d = self.theclass(2000, 12, 31)
1223 e = self.theclass(2000, 12, 31)
1224 self.assertEqual(d, e)
1225 self.assertEqual(hash(d), hash(e))
1229 self.assertEqual(len(dic), 1)
1230 self.assertEqual(dic[d], 2)
1231 self.assertEqual(dic[e], 2)
1233 d = self.theclass(2001, 1, 1)
1235 e = self.theclass(2001, 1, 1)
1236 self.assertEqual(d, e)
1237 self.assertEqual(hash(d), hash(e))
1241 self.assertEqual(len(dic), 1)
1242 self.assertEqual(dic[d], 2)
1243 self.assertEqual(dic[e], 2)
1245 def test_computations(self):
1246 a = self.theclass(2002, 1, 31)
1247 b = self.theclass(1956, 1, 31)
1248 c = self.theclass(2001,2,1)
1251 self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))
1252 self.assertEqual(diff.seconds, 0)
1253 self.assertEqual(diff.microseconds, 0)
1257 a = self.theclass(2002, 3, 2)
1258 self.assertEqual(a + day, self.theclass(2002, 3, 3))
1259 self.assertEqual(day + a, self.theclass(2002, 3, 3))
1260 self.assertEqual(a - day, self.theclass(2002, 3, 1))
1261 self.assertEqual(-day + a, self.theclass(2002, 3, 1))
1262 self.assertEqual(a + week, self.theclass(2002, 3, 9))
1263 self.assertEqual(a - week, self.theclass(2002, 2, 23))
1264 self.assertEqual(a + 52*week, self.theclass(2003, 3, 1))
1265 self.assertEqual(a - 52*week, self.theclass(2001, 3, 3))
1266 self.assertEqual((a + week) - a, week)
1267 self.assertEqual((a + day) - a, day)
1268 self.assertEqual((a - week) - a, -week)
1269 self.assertEqual((a - day) - a, -day)
1270 self.assertEqual(a - (a + week), -week)
1271 self.assertEqual(a - (a + day), -day)
1272 self.assertEqual(a - (a - week), week)
1273 self.assertEqual(a - (a - day), day)
1274 self.assertEqual(c - (c - day), day)
1278 self.assertRaises(TypeError, lambda: a+i)
1279 self.assertRaises(TypeError, lambda: a-i)
1280 self.assertRaises(TypeError, lambda: i+a)
1281 self.assertRaises(TypeError, lambda: i-a)
1284 self.assertRaises(TypeError, lambda: day - a)
1286 self.assertRaises(TypeError, lambda: day * a)
1287 self.assertRaises(TypeError, lambda: a * day)
1288 self.assertRaises(TypeError, lambda: day // a)
1289 self.assertRaises(TypeError, lambda: a // day)
1290 self.assertRaises(TypeError, lambda: a * a)
1291 self.assertRaises(TypeError, lambda: a // a)
1293 self.assertRaises(TypeError, lambda: a + a)
1295 def test_overflow(self):
1296 tiny = self.theclass.resolution
1299 dt = self.theclass.min + delta
1301 self.assertRaises(OverflowError, dt.__sub__, delta)
1302 self.assertRaises(OverflowError, dt.__add__, -delta)
1304 dt = self.theclass.max - delta
1306 self.assertRaises(OverflowError, dt.__add__, delta)
1307 self.assertRaises(OverflowError, dt.__sub__, -delta)
1309 def test_fromtimestamp(self):
1315 d = self.theclass.fromtimestamp(ts)
1316 self.assertEqual(d.year, year)
1317 self.assertEqual(d.month, month)
1318 self.assertEqual(d.day, day)
1320 def test_insane_fromtimestamp(self):
1326 self.assertRaises(OverflowError, self.theclass.fromtimestamp,
1329 def test_today(self):
1335 today = self.theclass.today()
1337 todayagain = self.theclass.fromtimestamp(ts)
1355 self.assertAlmostEqual(todayagain, today,
1358 def test_weekday(self):
1361 self.assertEqual(self.theclass(2002, 3, 4+i).weekday(), i)
1362 self.assertEqual(self.theclass(2002, 3, 4+i).isoweekday(), i+1)
1364 self.assertEqual(self.theclass(1956, 1, 2+i).weekday(), i)
1365 self.assertEqual(self.theclass(1956, 1, 2+i).isoweekday(), i+1)
1367 def test_isocalendar(self):
1381 base_date = self.theclass(*cal_date)
1389 with self.subTest(d=d, comparison="tuple"):
1390 self.assertEqual(d.isocalendar(), exp_iso)
1393 with self.subTest(d=d, comparison="fields"):
1395 self.assertEqual((t.year, t.week, t.weekday), exp_iso)
1397 def test_isocalendar_pickling(self):
1402 d = self.theclass(2019, 1, 1)
1405 self.assertEqual(type(res), tuple)
1406 self.assertEqual(res, (2019, 1, 2))
1408 def test_iso_long_years(self):
1439 d = self.theclass(2000+i, 12, 31)
1440 d1 = self.theclass(1600+i, 12, 31)
1441 self.assertEqual(d.isocalendar()[1:], d1.isocalendar()[1:])
1444 self.assertEqual(L, iso_long_years)
1446 def test_isoformat(self):
1447 t = self.theclass(2, 3, 2)
1448 self.assertEqual(t.isoformat(), "0002-03-02")
1450 def test_ctime(self):
1451 t = self.theclass(2002, 3, 2)
1452 self.assertEqual(t.ctime(), "Sat Mar 2 00:00:00 2002")
1454 def test_strftime(self):
1455 t = self.theclass(2005, 3, 2)
1456 self.assertEqual(t.strftime("m:%m d:%d y:%y"), "m:03 d:02 y:05")
1457 self.assertEqual(t.strftime(""), "") # SF bug #761337
1458 self.assertEqual(t.strftime('x'*1000), 'x'*1000) # SF bug #1556784
1460 self.assertRaises(TypeError, t.strftime) # needs an arg
1461 self.assertRaises(TypeError, t.strftime, "one", "two") # too many args
1462 self.assertRaises(TypeError, t.strftime, 42) # arg wrong type
1465 self.assertEqual(t.strftime("%m"), "03")
1468 self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")
1471 #self.assertRaises(ValueError, t.strftime, "%e")
1472 #self.assertRaises(ValueError, t.strftime, "%")
1473 #self.assertRaises(ValueError, t.strftime, "%#")
1493 def test_strftime_trailing_percent(self):
1498 t = self.theclass(2005, 3, 2)
1502 self.skipTest('time module does not support trailing %')
1503 self.assertEqual(t.strftime('%'), _time.strftime('%', t.timetuple()))
1504 self.assertEqual(
1509 def test_format(self):
1510 dt = self.theclass(2007, 9, 10)
1511 self.assertEqual(dt.__format__(''), str(dt))
1513 with self.assertRaisesRegex(TypeError, 'must be str, not int'):
1517 class A(self.theclass):
1518 def __str__(self):
1521 self.assertEqual(a.__format__(''), 'A')
1524 class B(self.theclass):
1525 def strftime(self, format_spec):
1528 self.assertEqual(b.__format__(''), str(dt))
1534 self.assertEqual(dt.__format__(fmt), dt.strftime(fmt))
1535 self.assertEqual(a.__format__(fmt), dt.strftime(fmt))
1536 self.assertEqual(b.__format__(fmt), 'B')
1538 def test_resolution_info(self):
1540 if issubclass(self.theclass, datetime):
1544 self.assertIsInstance(self.theclass.min, expected_class)
1545 self.assertIsInstance(self.theclass.max, expected_class)
1546 self.assertIsInstance(self.theclass.resolution, timedelta)
1547 self.assertTrue(self.theclass.max > self.theclass.min)
1549 def test_extreme_timedelta(self):
1550 big = self.theclass.max - self.theclass.min
1555 self.assertEqual(big, justasbig)
1556 self.assertEqual(self.theclass.min + big, self.theclass.max)
1557 self.assertEqual(self.theclass.max - big, self.theclass.min)
1559 def test_timetuple(self):
1562 d = self.theclass(1956, 1, 2+i)
1564 self.assertEqual(t, (1956, 1, 2+i, 0, 0, 0, i, 2+i, -1))
1566 d = self.theclass(1956, 2, 1+i)
1568 self.assertEqual(t, (1956, 2, 1+i, 0, 0, 0, (2+i)%7, 32+i, -1))
1571 d = self.theclass(1956, 3, 1+i)
1573 self.assertEqual(t, (1956, 3, 1+i, 0, 0, 0, (3+i)%7, 61+i, -1))
1574 self.assertEqual(t.tm_year, 1956)
1575 self.assertEqual(t.tm_mon, 3)
1576 self.assertEqual(t.tm_mday, 1+i)
1577 self.assertEqual(t.tm_hour, 0)
1578 self.assertEqual(t.tm_min, 0)
1579 self.assertEqual(t.tm_sec, 0)
1580 self.assertEqual(t.tm_wday, (3+i)%7)
1581 self.assertEqual(t.tm_yday, 61+i)
1582 self.assertEqual(t.tm_isdst, -1)
1584 def test_pickling(self):
1586 orig = self.theclass(*args)
1590 self.assertEqual(orig, derived)
1591 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
1593 def test_compat_unpickle(self):
1600 expected = self.theclass(*args)
1604 self.assertEqual(derived, expected)
1606 def test_compare(self):
1607 t1 = self.theclass(2, 3, 4)
1608 t2 = self.theclass(2, 3, 4)
1609 self.assertEqual(t1, t2)
1610 self.assertTrue(t1 <= t2)
1611 self.assertTrue(t1 >= t2)
1612 self.assertFalse(t1 != t2)
1613 self.assertFalse(t1 < t2)
1614 self.assertFalse(t1 > t2)
1617 t2 = self.theclass(*args) # this is larger than t1
1618 self.assertTrue(t1 < t2)
1619 self.assertTrue(t2 > t1)
1620 self.assertTrue(t1 <= t2)
1621 self.assertTrue(t2 >= t1)
1622 self.assertTrue(t1 != t2)
1623 self.assertTrue(t2 != t1)
1624 self.assertFalse(t1 == t2)
1625 self.assertFalse(t2 == t1)
1626 self.assertFalse(t1 > t2)
1627 self.assertFalse(t2 < t1)
1628 self.assertFalse(t1 >= t2)
1629 self.assertFalse(t2 <= t1)
1632 self.assertEqual(t1 == badarg, False)
1633 self.assertEqual(t1 != badarg, True)
1634 self.assertEqual(badarg == t1, False)
1635 self.assertEqual(badarg != t1, True)
1637 self.assertRaises(TypeError, lambda: t1 < badarg)
1638 self.assertRaises(TypeError, lambda: t1 > badarg)
1639 self.assertRaises(TypeError, lambda: t1 >= badarg)
1640 self.assertRaises(TypeError, lambda: badarg <= t1)
1641 self.assertRaises(TypeError, lambda: badarg < t1)
1642 self.assertRaises(TypeError, lambda: badarg > t1)
1643 self.assertRaises(TypeError, lambda: badarg >= t1)
1645 def test_mixed_compare(self):
1646 our = self.theclass(2000, 4, 5)
1649 self.assertEqual(our == 1, False)
1650 self.assertEqual(1 == our, False)
1651 self.assertEqual(our != 1, True)
1652 self.assertEqual(1 != our, True)
1655 self.assertRaises(TypeError, lambda: our < 1)
1656 self.assertRaises(TypeError, lambda: 1 < our)
1664 self.assertEqual(our == their, False)
1665 self.assertEqual(their == our, False)
1666 self.assertEqual(our != their, True)
1667 self.assertEqual(their != our, True)
1668 self.assertRaises(TypeError, lambda: our < their)
1669 self.assertRaises(TypeError, lambda: their < our)
1671 def test_bool(self):
1673 self.assertTrue(self.theclass.min)
1674 self.assertTrue(self.theclass.max)
1676 def test_strftime_y2k(self):
1678 d = self.theclass(y, 1, 1)
1685 self.assertEqual(d.strftime("%Y"), '%d' % y)
1688 self.assertEqual(d.strftime("%4Y"), '%04d' % y)
1690 def test_replace(self):
1691 cls = self.theclass
1694 self.assertEqual(base, base.replace())
1704 self.assertEqual(expected, got)
1709 self.assertRaises(ValueError, base.replace, year=2001)
1711 def test_subclass_replace(self):
1712 class DateSubclass(self.theclass):
1716 self.assertIs(type(dt.replace(year=2013)), DateSubclass)
1718 def test_subclass_date(self):
1720 class C(self.theclass):
1726 result = self.theclass.__new__(cls, *args, **temp)
1730 def newmeth(self, start):
1731 return start + self.year + self.month
1735 dt1 = self.theclass(*args)
1738 self.assertEqual(dt2.__class__, C)
1739 self.assertEqual(dt2.theAnswer, 42)
1740 self.assertEqual(dt2.extra, 7)
1741 self.assertEqual(dt1.toordinal(), dt2.toordinal())
1742 self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month - 7)
1744 def test_subclass_alternate_constructors(self):
1746 class DateSubclass(self.theclass):
1748 result = self.theclass.__new__(cls, *args, **kwargs)
1758 self.assertIsInstance(base_d, DateSubclass)
1759 self.assertEqual(base_d.extra, 7)
1773 with self.subTest(base_obj_type=type(base_obj),
1780 self.assertIsInstance(dt, DateSubclass)
1783 self.assertEqual(dt, base_d)
1786 self.assertEqual(dt.extra, 7)
1788 def test_pickling_subclass_date(self):
1795 self.assertEqual(orig, derived)
1796 self.assertTrue(isinstance(derived, SubclassDate))
1798 def test_backdoor_resistance(self):
1808 if not issubclass(self.theclass, datetime):
1811 self.assertRaises(TypeError, self.theclass,
1813 if issubclass(self.theclass, datetime):
1815 with self.assertRaisesRegex(TypeError, '^bad tzinfo state arg$'):
1816 self.theclass(bytes([1] * len(base)), 'EST')
1822 self.theclass(base[:2] + bytes([ord_byte]) + base[3:])
1824 def test_fromisoformat(self):
1837 dt = self.theclass(*dt_tuple)
1839 with self.subTest(dt_str=dt_str):
1840 dt_rt = self.theclass.fromisoformat(dt.isoformat())
1842 self.assertEqual(dt, dt_rt)
1844 def test_fromisoformat_date_examples(self):
1846 ('00010101', self.theclass(1, 1, 1)),
1847 ('20000101', self.theclass(2000, 1, 1)),
1848 ('20250102', self.theclass(2025, 1, 2)),
1849 ('99991231', self.theclass(9999, 12, 31)),
1850 ('0001-01-01', self.theclass(1, 1, 1)),
1851 ('2000-01-01', self.theclass(2000, 1, 1)),
1852 ('2025-01-02', self.theclass(2025, 1, 2)),
1853 ('9999-12-31', self.theclass(9999, 12, 31)),
1854 ('2025W01', self.theclass(2024, 12, 30)),
1855 ('2025-W01', self.theclass(2024, 12, 30)),
1856 ('2025W014', self.theclass(2025, 1, 2)),
1857 ('2025-W01-4', self.theclass(2025, 1, 2)),
1858 ('2026W01', self.theclass(2025, 12, 29)),
1859 ('2026-W01', self.theclass(2025, 12, 29)),
1860 ('2026W013', self.theclass(2025, 12, 31)),
1861 ('2026-W01-3', self.theclass(2025, 12, 31)),
1862 ('2022W52', self.theclass(2022, 12, 26)),
1863 ('2022-W52', self.theclass(2022, 12, 26)),
1864 ('2022W527', self.theclass(2023, 1, 1)),
1865 ('2022-W52-7', self.theclass(2023, 1, 1)),
1866 ('2015W534', self.theclass(2015, 12, 31)), # Has week 53
1867 ('2015-W53-4', self.theclass(2015, 12, 31)), # Has week 53
1868 ('2015-W53-5', self.theclass(2016, 1, 1)),
1869 ('2020W531', self.theclass(2020, 12, 28)), # Leap year
1870 ('2020-W53-1', self.theclass(2020, 12, 28)), # Leap year
1871 ('2020-W53-6', self.theclass(2021, 1, 2)),
1875 with self.subTest(input_str=input_str):
1876 actual = self.theclass.fromisoformat(input_str)
1877 self.assertEqual(actual, expected)
1879 def test_fromisoformat_subclass(self):
1880 class DateSubclass(self.theclass):
1887 self.assertIsInstance(dt_rt, DateSubclass)
1889 def test_fromisoformat_fails(self):
1907 with self.assertRaises(ValueError):
1908 self.theclass.fromisoformat(bad_str)
1910 def test_fromisoformat_fails_typeerror(self):
1914 with self.assertRaises(TypeError):
1915 self.theclass.fromisoformat(bad_type)
1917 def test_fromisocalendar(self):
1939 with self.subTest(datecomps=datecomps):
1940 dobj = self.theclass(*datecomps)
1943 d_roundtrip = self.theclass.fromisocalendar(*isocal)
1945 self.assertEqual(dobj, d_roundtrip)
1947 def test_fromisocalendar_value_errors(self):
1965 with self.subTest(isocal=isocal):
1966 with self.assertRaises(ValueError):
1967 self.theclass.fromisocalendar(*isocal)
1969 def test_fromisocalendar_type_errors(self):
1988 with self.subTest(isocal=isocal):
1989 with self.assertRaises(TypeError):
1990 self.theclass.fromisocalendar(*isocal)
2003 def test_basic_attributes(self):
2004 dt = self.theclass(2002, 3, 1, 12, 0)
2005 self.assertEqual(dt.year, 2002)
2006 self.assertEqual(dt.month, 3)
2007 self.assertEqual(dt.day, 1)
2008 self.assertEqual(dt.hour, 12)
2009 self.assertEqual(dt.minute, 0)
2010 self.assertEqual(dt.second, 0)
2011 self.assertEqual(dt.microsecond, 0)
2013 def test_basic_attributes_nonzero(self):
2016 dt = self.theclass(2002, 3, 1, 12, 59, 59, 8000)
2017 self.assertEqual(dt.year, 2002)
2018 self.assertEqual(dt.month, 3)
2019 self.assertEqual(dt.day, 1)
2020 self.assertEqual(dt.hour, 12)
2021 self.assertEqual(dt.minute, 59)
2022 self.assertEqual(dt.second, 59)
2023 self.assertEqual(dt.microsecond, 8000)
2025 def test_roundtrip(self):
2026 for dt in (self.theclass(1, 2, 3, 4, 5, 6, 7),
2027 self.theclass.now()):
2030 self.assertTrue(s.startswith('datetime.'))
2033 self.assertEqual(dt, dt2)
2036 dt2 = self.theclass(dt.year, dt.month, dt.day,
2039 self.assertEqual(dt, dt2)
2041 def test_isoformat(self):
2042 t = self.theclass(1, 2, 3, 4, 5, 1, 123)
2043 self.assertEqual(t.isoformat(), "0001-02-03T04:05:01.000123")
2044 self.assertEqual(t.isoformat('T'), "0001-02-03T04:05:01.000123")
2045 self.assertEqual(t.isoformat(' '), "0001-02-03 04:05:01.000123")
2046 self.assertEqual(t.isoformat('\x00'), "0001-02-03\x0004:05:01.000123")
2048 self.assertEqual(t.isoformat('\ud800'),
2050 self.assertEqual(t.isoformat(timespec='hours'), "0001-02-03T04")
2051 self.assertEqual(t.isoformat(timespec='minutes'), "0001-02-03T04:05")
2052 self.assertEqual(t.isoformat(timespec='seconds'), "0001-02-03T04:05:01")
2053 self.assertEqual(t.isoformat(timespec='milliseconds'), "0001-02-03T04:05:01.000")
2054 self.assertEqual(t.isoformat(timespec='microseconds'), "0001-02-03T04:05:01.000123")
2055 self.assertEqual(t.isoformat(timespec='auto'), "0001-02-03T04:05:01.000123")
2056 self.assertEqual(t.isoformat(sep=' ', timespec='minutes'), "0001-02-03 04:05")
2057 self.assertRaises(ValueError, t.isoformat, timespec='foo')
2059 self.assertRaises(ValueError, t.isoformat, timespec='\ud800')
2061 self.assertEqual(str(t), "0001-02-03 04:05:01.000123")
2063 t = self.theclass(1, 2, 3, 4, 5, 1, 999500, tzinfo=timezone.utc)
2064 self.assertEqual(t.isoformat(timespec='milliseconds'), "0001-02-03T04:05:01.999+00:00")
2066 t = self.theclass(1, 2, 3, 4, 5, 1, 999500)
2067 self.assertEqual(t.isoformat(timespec='milliseconds'), "0001-02-03T04:05:01.999")
2069 t = self.theclass(1, 2, 3, 4, 5, 1)
2070 self.assertEqual(t.isoformat(timespec='auto'), "0001-02-03T04:05:01")
2071 self.assertEqual(t.isoformat(timespec='milliseconds'), "0001-02-03T04:05:01.000")
2072 self.assertEqual(t.isoformat(timespec='microseconds'), "0001-02-03T04:05:01.000000")
2074 t = self.theclass(2, 3, 2)
2075 self.assertEqual(t.isoformat(), "0002-03-02T00:00:00")
2076 self.assertEqual(t.isoformat('T'), "0002-03-02T00:00:00")
2077 self.assertEqual(t.isoformat(' '), "0002-03-02 00:00:00")
2079 self.assertEqual(str(t), "0002-03-02 00:00:00")
2082 t = self.theclass(2, 3, 2, tzinfo=tz)
2083 self.assertEqual(t.isoformat(), "0002-03-02T00:00:00+00:00:16")
2085 def test_isoformat_timezone(self):
2106 dt_base = self.theclass(2016, 4, 1, 12, 37, 9)
2112 with self.subTest(tzi=tzi):
2115 def test_format(self):
2116 dt = self.theclass(2007, 9, 10, 4, 5, 1, 123)
2117 self.assertEqual(dt.__format__(''), str(dt))
2119 with self.assertRaisesRegex(TypeError, 'must be str, not int'):
2123 class A(self.theclass):
2124 def __str__(self):
2127 self.assertEqual(a.__format__(''), 'A')
2130 class B(self.theclass):
2131 def strftime(self, format_spec):
2134 self.assertEqual(b.__format__(''), str(dt))
2140 self.assertEqual(dt.__format__(fmt), dt.strftime(fmt))
2141 self.assertEqual(a.__format__(fmt), dt.strftime(fmt))
2142 self.assertEqual(b.__format__(fmt), 'B')
2144 def test_more_ctime(self):
2148 t = self.theclass(2002, 3, 2, 18, 3, 5, 123)
2149 self.assertEqual(t.ctime(), "Sat Mar 2 18:03:05 2002")
2154 # self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))
2157 t = self.theclass(2002, 3, 22, 18, 3, 5, 123)
2158 self.assertEqual(t.ctime(), time.ctime(time.mktime(t.timetuple())))
2160 def test_tz_independent_comparing(self):
2161 dt1 = self.theclass(2002, 3, 1, 9, 0, 0)
2162 dt2 = self.theclass(2002, 3, 1, 10, 0, 0)
2163 dt3 = self.theclass(2002, 3, 1, 9, 0, 0)
2164 self.assertEqual(dt1, dt3)
2165 self.assertTrue(dt2 > dt3)
2172 dt1 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999998)
2175 self.assertEqual(dt2 - dt1, us)
2176 self.assertTrue(dt1 < dt2)
2178 def test_strftime_with_bad_tzname_replace(self):
2181 def tzname(self, dt):
2183 def replace(self, *args):
2186 t = self.theclass(2005, 3, 2, 0, 0, 0, 0, MyTzInfo(3, 'name'))
2187 self.assertRaises(TypeError, t.strftime, '%Z')
2189 def test_bad_constructor_arguments(self):
2191 self.theclass(MINYEAR, 1, 1) # no exception
2192 self.theclass(MAXYEAR, 1, 1) # no exception
2193 self.assertRaises(ValueError, self.theclass, MINYEAR-1, 1, 1)
2194 self.assertRaises(ValueError, self.theclass, MAXYEAR+1, 1, 1)
2196 self.theclass(2000, 1, 1) # no exception
2197 self.theclass(2000, 12, 1) # no exception
2198 self.assertRaises(ValueError, self.theclass, 2000, 0, 1)
2199 self.assertRaises(ValueError, self.theclass, 2000, 13, 1)
2201 self.theclass(2000, 2, 29) # no exception
2202 self.theclass(2004, 2, 29) # no exception
2203 self.theclass(2400, 2, 29) # no exception
2204 self.assertRaises(ValueError, self.theclass, 2000, 2, 30)
2205 self.assertRaises(ValueError, self.theclass, 2001, 2, 29)
2206 self.assertRaises(ValueError, self.theclass, 2100, 2, 29)
2207 self.assertRaises(ValueError, self.theclass, 1900, 2, 29)
2208 self.assertRaises(ValueError, self.theclass, 2000, 1, 0)
2209 self.assertRaises(ValueError, self.theclass, 2000, 1, 32)
2211 self.theclass(2000, 1, 31, 0) # no exception
2212 self.theclass(2000, 1, 31, 23) # no exception
2213 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, -1)
2214 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 24)
2216 self.theclass(2000, 1, 31, 23, 0) # no exception
2217 self.theclass(2000, 1, 31, 23, 59) # no exception
2218 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, -1)
2219 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 60)
2221 self.theclass(2000, 1, 31, 23, 59, 0) # no exception
2222 self.theclass(2000, 1, 31, 23, 59, 59) # no exception
2223 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, -1)
2224 self.assertRaises(ValueError, self.theclass, 2000, 1, 31, 23, 59, 60)
2226 self.theclass(2000, 1, 31, 23, 59, 59, 0) # no exception
2227 self.theclass(2000, 1, 31, 23, 59, 59, 999999) # no exception
2228 self.assertRaises(ValueError, self.theclass,
2230 self.assertRaises(ValueError, self.theclass,
2234 self.assertRaises(ValueError, self.theclass,
2236 self.assertRaises(ValueError, self.theclass,
2239 self.assertRaises(TypeError, self.theclass,
2242 def test_hash_equality(self):
2243 d = self.theclass(2000, 12, 31, 23, 30, 17)
2244 e = self.theclass(2000, 12, 31, 23, 30, 17)
2245 self.assertEqual(d, e)
2246 self.assertEqual(hash(d), hash(e))
2250 self.assertEqual(len(dic), 1)
2251 self.assertEqual(dic[d], 2)
2252 self.assertEqual(dic[e], 2)
2254 d = self.theclass(2001, 1, 1, 0, 5, 17)
2255 e = self.theclass(2001, 1, 1, 0, 5, 17)
2256 self.assertEqual(d, e)
2257 self.assertEqual(hash(d), hash(e))
2261 self.assertEqual(len(dic), 1)
2262 self.assertEqual(dic[d], 2)
2263 self.assertEqual(dic[e], 2)
2265 def test_computations(self):
2266 a = self.theclass(2002, 1, 31)
2267 b = self.theclass(1956, 1, 31)
2269 self.assertEqual(diff.days, 46*365 + len(range(1956, 2002, 4)))
2270 self.assertEqual(diff.seconds, 0)
2271 self.assertEqual(diff.microseconds, 0)
2272 a = self.theclass(2002, 3, 2, 17, 6)
2277 self.assertEqual(a + hour, self.theclass(2002, 3, 2, 18, 6))
2278 self.assertEqual(hour + a, self.theclass(2002, 3, 2, 18, 6))
2279 self.assertEqual(a + 10*hour, self.theclass(2002, 3, 3, 3, 6))
2280 self.assertEqual(a - hour, self.theclass(2002, 3, 2, 16, 6))
2281 self.assertEqual(-hour + a, self.theclass(2002, 3, 2, 16, 6))
2282 self.assertEqual(a - hour, a + -hour)
2283 self.assertEqual(a - 20*hour, self.theclass(2002, 3, 1, 21, 6))
2284 self.assertEqual(a + day, self.theclass(2002, 3, 3, 17, 6))
2285 self.assertEqual(a - day, self.theclass(2002, 3, 1, 17, 6))
2286 self.assertEqual(a + week, self.theclass(2002, 3, 9, 17, 6))
2287 self.assertEqual(a - week, self.theclass(2002, 2, 23, 17, 6))
2288 self.assertEqual(a + 52*week, self.theclass(2003, 3, 1, 17, 6))
2289 self.assertEqual(a - 52*week, self.theclass(2001, 3, 3, 17, 6))
2290 self.assertEqual((a + week) - a, week)
2291 self.assertEqual((a + day) - a, day)
2292 self.assertEqual((a + hour) - a, hour)
2293 self.assertEqual((a + millisec) - a, millisec)
2294 self.assertEqual((a - week) - a, -week)
2295 self.assertEqual((a - day) - a, -day)
2296 self.assertEqual((a - hour) - a, -hour)
2297 self.assertEqual((a - millisec) - a, -millisec)
2298 self.assertEqual(a - (a + week), -week)
2299 self.assertEqual(a - (a + day), -day)
2300 self.assertEqual(a - (a + hour), -hour)
2301 self.assertEqual(a - (a + millisec), -millisec)
2302 self.assertEqual(a - (a - week), week)
2303 self.assertEqual(a - (a - day), day)
2304 self.assertEqual(a - (a - hour), hour)
2305 self.assertEqual(a - (a - millisec), millisec)
2306 self.assertEqual(a + (week + day + hour + millisec),
2307 self.theclass(2002, 3, 10, 18, 6, 0, 1000))
2308 self.assertEqual(a + (week + day + hour + millisec),
2310 self.assertEqual(a - (week + day + hour + millisec),
2311 self.theclass(2002, 2, 22, 16, 5, 59, 999000))
2312 self.assertEqual(a - (week + day + hour + millisec),
2316 self.assertRaises(TypeError, lambda: a+i)
2317 self.assertRaises(TypeError, lambda: a-i)
2318 self.assertRaises(TypeError, lambda: i+a)
2319 self.assertRaises(TypeError, lambda: i-a)
2322 self.assertRaises(TypeError, lambda: day - a)
2324 self.assertRaises(TypeError, lambda: day * a)
2325 self.assertRaises(TypeError, lambda: a * day)
2326 self.assertRaises(TypeError, lambda: day // a)
2327 self.assertRaises(TypeError, lambda: a // day)
2328 self.assertRaises(TypeError, lambda: a * a)
2329 self.assertRaises(TypeError, lambda: a // a)
2331 self.assertRaises(TypeError, lambda: a + a)
2333 def test_pickling(self):
2335 orig = self.theclass(*args)
2339 self.assertEqual(orig, derived)
2340 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
2342 def test_more_pickling(self):
2343 a = self.theclass(2003, 2, 7, 16, 48, 37, 444116)
2347 self.assertEqual(b.year, 2003)
2348 self.assertEqual(b.month, 2)
2349 self.assertEqual(b.day, 7)
2351 def test_pickling_subclass_datetime(self):
2357 self.assertEqual(orig, derived)
2358 self.assertTrue(isinstance(derived, SubclassDatetime))
2360 def test_compat_unpickle(self):
2372 expected = self.theclass(*args)
2376 self.assertEqual(derived, expected)
2378 def test_more_compare(self):
2383 t1 = self.theclass(*args)
2384 t2 = self.theclass(*args)
2385 self.assertEqual(t1, t2)
2386 self.assertTrue(t1 <= t2)
2387 self.assertTrue(t1 >= t2)
2388 self.assertFalse(t1 != t2)
2389 self.assertFalse(t1 < t2)
2390 self.assertFalse(t1 > t2)
2395 t2 = self.theclass(*newargs) # this is larger than t1
2396 self.assertTrue(t1 < t2)
2397 self.assertTrue(t2 > t1)
2398 self.assertTrue(t1 <= t2)
2399 self.assertTrue(t2 >= t1)
2400 self.assertTrue(t1 != t2)
2401 self.assertTrue(t2 != t1)
2402 self.assertFalse(t1 == t2)
2403 self.assertFalse(t2 == t1)
2404 self.assertFalse(t1 > t2)
2405 self.assertFalse(t2 < t1)
2406 self.assertFalse(t1 >= t2)
2407 self.assertFalse(t2 <= t1)
2411 def verify_field_equality(self, expected, got):
2412 self.assertEqual(expected.tm_year, got.year)
2413 self.assertEqual(expected.tm_mon, got.month)
2414 self.assertEqual(expected.tm_mday, got.day)
2415 self.assertEqual(expected.tm_hour, got.hour)
2416 self.assertEqual(expected.tm_min, got.minute)
2417 self.assertEqual(expected.tm_sec, got.second)
2419 def test_fromtimestamp(self):
2424 got = self.theclass.fromtimestamp(ts)
2425 self.verify_field_equality(expected, got)
2427 def test_utcfromtimestamp(self):
2432 got = self.theclass.utcfromtimestamp(ts)
2433 self.verify_field_equality(expected, got)
2438 def test_timestamp_naive(self):
2439 t = self.theclass(1970, 1, 1)
2440 self.assertEqual(t.timestamp(), 18000.0)
2441 t = self.theclass(1970, 1, 1, 1, 2, 3, 4)
2442 self.assertEqual(t.timestamp(),
2445 t0 = self.theclass(2012, 3, 11, 2, 30)
2447 self.assertEqual(self.theclass.fromtimestamp(t1.timestamp()),
2449 self.assertEqual(self.theclass.fromtimestamp(t0.timestamp()),
2452 t = self.theclass(2012, 11, 4, 1, 30)
2453 self.assertEqual(self.theclass.fromtimestamp(t.timestamp()), t)
2457 for t in [self.theclass(2,1,1), self.theclass(9998,12,12)]:
2463 self.assertEqual(self.theclass.fromtimestamp(s), t)
2465 def test_timestamp_aware(self):
2466 t = self.theclass(1970, 1, 1, tzinfo=timezone.utc)
2467 self.assertEqual(t.timestamp(), 0.0)
2468 t = self.theclass(1970, 1, 1, 1, 2, 3, 4, tzinfo=timezone.utc)
2469 self.assertEqual(t.timestamp(),
2471 t = self.theclass(1970, 1, 1, 1, 2, 3, 4,
2473 self.assertEqual(t.timestamp(),
2477 def test_microsecond_rounding(self):
2478 for fts in [self.theclass.fromtimestamp,
2479 self.theclass.utcfromtimestamp]:
2481 self.assertEqual(zero.second, 0)
2482 self.assertEqual(zero.microsecond, 0)
2490 self.assertEqual(minus_one.second, 59)
2491 self.assertEqual(minus_one.microsecond, 999999)
2494 self.assertEqual(t, zero)
2496 self.assertEqual(t, minus_one)
2498 self.assertEqual(t, zero)
2500 self.assertEqual(t.second, 59)
2501 self.assertEqual(t.microsecond, 992188)
2504 self.assertEqual(t, zero)
2506 self.assertEqual(t, one)
2508 self.assertEqual(t.second, 0)
2509 self.assertEqual(t.microsecond, 999999)
2511 self.assertEqual(t.second, 1)
2512 self.assertEqual(t.microsecond, 0)
2514 self.assertEqual(t.second, 0)
2515 self.assertEqual(t.microsecond, 7812)
2517 def test_timestamp_limits(self):
2518 with self.subTest("minimum UTC"):
2519 min_dt = self.theclass.min.replace(tzinfo=timezone.utc)
2524 self.assertEqual(min_ts, -62135596800)
2526 with self.subTest("maximum UTC"):
2528 max_dt = self.theclass.max.replace(tzinfo=timezone.utc,
2534 self.assertEqual(max_ts, 253402300799.0)
2536 def test_fromtimestamp_limits(self):
2538 self.theclass.fromtimestamp(-2**32 - 1)
2540 self.skipTest("Test not valid on this platform")
2544 min_dt = self.theclass.min + timedelta(days=1)
2547 max_dt = self.theclass.max.replace(microsecond=0)
2548 max_ts = ((self.theclass.max - timedelta(hours=23)).timestamp() +
2555 with self.subTest(test_name, ts=ts, expected=expected):
2556 actual = self.theclass.fromtimestamp(ts)
2558 self.assertEqual(actual, expected)
2569 with self.subTest(test_name, ts=ts):
2570 with self.assertRaises((ValueError, OverflowError)):
2573 self.theclass.fromtimestamp(ts)
2575 def test_utcfromtimestamp_limits(self):
2577 self.theclass.utcfromtimestamp(-2**32 - 1)
2579 self.skipTest("Test not valid on this platform")
2581 min_dt = self.theclass.min.replace(tzinfo=timezone.utc)
2584 max_dt = self.theclass.max.replace(microsecond=0, tzinfo=timezone.utc)
2591 with self.subTest(test_name, ts=ts, expected=expected):
2593 actual = self.theclass.utcfromtimestamp(ts)
2595 self.skipTest(str(exc))
2597 self.assertEqual(actual, expected)
2608 with self.subTest(test_name, ts=ts):
2609 with self.assertRaises((ValueError, OverflowError)):
2612 self.theclass.utcfromtimestamp(ts)
2614 def test_insane_fromtimestamp(self):
2620 self.assertRaises(OverflowError, self.theclass.fromtimestamp,
2623 def test_insane_utcfromtimestamp(self):
2629 self.assertRaises(OverflowError, self.theclass.utcfromtimestamp,
2633 def test_negative_float_fromtimestamp(self):
2636 self.theclass.fromtimestamp(-1.05)
2639 def test_negative_float_utcfromtimestamp(self):
2640 d = self.theclass.utcfromtimestamp(-1.05)
2641 self.assertEqual(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
2643 def test_utcnow(self):
2650 from_now = self.theclass.utcnow()
2651 from_timestamp = self.theclass.utcfromtimestamp(time.time())
2655 self.assertLessEqual(abs(from_timestamp - from_now), tolerance)
2657 def test_strptime(self):
2660 expected = _strptime._strptime_datetime(self.theclass, string, format)
2661 got = self.theclass.strptime(string, format)
2662 self.assertEqual(expected, got)
2663 self.assertIs(type(expected), self.theclass)
2664 self.assertIs(type(got), self.theclass)
2673 with self.subTest(string=string, format=format):
2674 expected = _strptime._strptime_datetime(self.theclass, string,
2676 got = self.theclass.strptime(string, format)
2677 self.assertEqual(expected, got)
2679 strptime = self.theclass.strptime
2681 self.assertEqual(strptime("+0002", "%z").utcoffset(), 2 * MINUTE)
2682 self.assertEqual(strptime("-0002", "%z").utcoffset(), -2 * MINUTE)
2683 self.assertEqual(
2699 self.assertEqual(dt.utcoffset(), timedelta(seconds=tzseconds))
2700 self.assertEqual(dt.tzname(), tzname)
2704 self.assertEqual(dt.utcoffset(), 12 * HOUR + 34 * MINUTE)
2705 self.assertEqual(dt.tzname(), 'UTC')
2707 self.assertEqual(dt.strftime(fmt), dtstr)
2710 self.assertEqual(strptime("UTC", "%Z").tzinfo, None)
2712 with self.assertRaises(ValueError): strptime("-2400", "%z")
2713 with self.assertRaises(ValueError): strptime("-000", "%z")
2714 with self.assertRaises(ValueError): strptime("z", "%z")
2716 def test_strptime_single_digit(self):
2719 strptime = self.theclass.strptime
2721 with self.assertRaises(ValueError):
2724 dt1 = self.theclass(2003, 2, 1, 4, 5, 6)
2725 dt2 = self.theclass(2003, 1, 2, 4, 5, 6)
2726 dt3 = self.theclass(2003, 2, 1, 0, 0, 0)
2727 dt4 = self.theclass(2003, 1, 25, 0, 0, 0)
2743 with self.subTest(reason=reason,
2748 self.assertEqual(newdate, target, msg=reason)
2750 def test_more_timetuple(self):
2752 t = self.theclass(2004, 12, 31, 6, 22, 33)
2753 self.assertEqual(t.timetuple(), (2004, 12, 31, 6, 22, 33, 4, 366, -1))
2754 self.assertEqual(t.timetuple(),
2761 self.assertEqual(tt.tm_year, t.year)
2762 self.assertEqual(tt.tm_mon, t.month)
2763 self.assertEqual(tt.tm_mday, t.day)
2764 self.assertEqual(tt.tm_hour, t.hour)
2765 self.assertEqual(tt.tm_min, t.minute)
2766 self.assertEqual(tt.tm_sec, t.second)
2767 self.assertEqual(tt.tm_wday, t.weekday())
2768 self.assertEqual(tt.tm_yday, t.toordinal() -
2770 self.assertEqual(tt.tm_isdst, -1)
2772 def test_more_strftime(self):
2774 t = self.theclass(2004, 12, 31, 6, 22, 33, 47)
2775 self.assertEqual(t.strftime("%m %d %y %f %S %M %H %j"),
2780 self.assertEqual(t.strftime("%z"), "-0200" + z)
2788 def test_extract(self):
2789 dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
2790 self.assertEqual(dt.date(), date(2002, 3, 4))
2791 self.assertEqual(dt.time(), time(18, 45, 3, 1234))
2793 def test_combine(self):
2796 expected = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
2797 combine = self.theclass.combine
2799 self.assertEqual(dt, expected)
2802 self.assertEqual(dt, expected)
2804 self.assertEqual(d, dt.date())
2805 self.assertEqual(t, dt.time())
2806 self.assertEqual(dt, combine(dt.date(), dt.time()))
2808 self.assertRaises(TypeError, combine) # need an arg
2809 self.assertRaises(TypeError, combine, d) # need two args
2810 self.assertRaises(TypeError, combine, t, d) # args reversed
2811 self.assertRaises(TypeError, combine, d, t, 1) # wrong tzinfo type
2812 self.assertRaises(TypeError, combine, d, t, 1, 2) # too many args
2813 self.assertRaises(TypeError, combine, "date", "time") # wrong types
2814 self.assertRaises(TypeError, combine, d, "time") # wrong type
2815 self.assertRaises(TypeError, combine, "date", t) # wrong type
2819 self.assertIs(dt.tzinfo, timezone.utc)
2821 self.assertIs(dt.tzinfo, timezone.utc)
2824 self.assertEqual(dt.date(), d)
2825 self.assertEqual(dt.time(), t)
2827 def test_replace(self):
2828 cls = self.theclass
2831 self.assertEqual(base, base.replace())
2845 self.assertEqual(expected, got)
2850 self.assertRaises(ValueError, base.replace, year=2001)
2853 def test_astimezone(self):
2854 dt = self.theclass.now()
2857 self.assertEqual(dt.astimezone(), dt_utc) # naive
2858 self.assertRaises(TypeError, dt.astimezone, f, f) # too many args
2859 self.assertRaises(TypeError, dt.astimezone, dt) # arg wrong type
2861 self.assertEqual(dt.astimezone(f), dt_f) # naive
2862 self.assertEqual(dt.astimezone(tz=f), dt_f) # naive
2865 def utcoffset(self, dt): return None
2866 def dst(self, dt): return timedelta(0)
2868 self.assertRaises(ValueError, dt.astimezone, bog) # naive
2869 self.assertEqual(dt.replace(tzinfo=bog).astimezone(f), dt_f)
2872 def utcoffset(self, dt): return timedelta(0)
2873 def dst(self, dt): return None
2875 self.assertRaises(ValueError, dt.astimezone, alsobog) # also naive
2878 def utcoffset(self, dt): return 1
2879 def dst(self, dt): return 1
2882 with self.assertRaises(TypeError):
2885 def test_subclass_datetime(self):
2887 class C(self.theclass):
2893 result = self.theclass.__new__(cls, *args, **temp)
2897 def newmeth(self, start):
2898 return start + self.year + self.month + self.second
2902 dt1 = self.theclass(*args)
2905 self.assertEqual(dt2.__class__, C)
2906 self.assertEqual(dt2.theAnswer, 42)
2907 self.assertEqual(dt2.extra, 7)
2908 self.assertEqual(dt1.toordinal(), dt2.toordinal())
2909 self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month +
2912 def test_subclass_alternate_constructors_datetime(self):
2914 class DateTimeSubclass(self.theclass):
2916 result = self.theclass.__new__(cls, *args, **kwargs)
2926 self.assertIsInstance(base_d, DateTimeSubclass)
2927 self.assertEqual(base_d.extra, 7)
2946 with self.subTest(base_obj_type=type(base_obj),
2953 self.assertIsInstance(dt, DateTimeSubclass)
2956 self.assertEqual(dt, expected)
2959 self.assertEqual(dt.extra, 7)
2961 def test_subclass_now(self):
2963 class DateTimeSubclass(self.theclass):
2965 result = self.theclass.__new__(cls, *args, **kwargs)
2978 with self.subTest(name):
2982 self.assertIsInstance(dt, DateTimeSubclass)
2983 self.assertEqual(dt.extra, 7)
2985 def test_fromisoformat_datetime(self):
3007 dts = [self.theclass(*date_tuple, *time_tuple, tzinfo=tzi)
3016 with self.subTest(dtstr=dtstr):
3017 dt_rt = self.theclass.fromisoformat(dtstr)
3018 self.assertEqual(dt, dt_rt)
3020 def test_fromisoformat_timezone(self):
3021 base_dt = self.theclass(2014, 12, 30, 12, 30, 45, 217456)
3041 with self.subTest(tstr=dtstr):
3042 dt_rt = self.theclass.fromisoformat(dtstr)
3045 def test_fromisoformat_separators(self):
3055 dt = self.theclass(2018, 1, 31, 23, 59, 47, 124789)
3058 with self.subTest(dtstr=dtstr):
3059 dt_rt = self.theclass.fromisoformat(dtstr)
3060 self.assertEqual(dt, dt_rt)
3062 def test_fromisoformat_ambiguous(self):
3066 dt = self.theclass(2018, 1, 31, 12, 15)
3069 with self.subTest(dtstr=dtstr):
3070 dt_rt = self.theclass.fromisoformat(dtstr)
3071 self.assertEqual(dt, dt_rt)
3073 def test_fromisoformat_timespecs(self):
3093 dt = self.theclass(*(dt_tuple[0:(4 + ip)]), tzinfo=tzi)
3095 with self.subTest(dtstr=dtstr):
3096 dt_rt = self.theclass.fromisoformat(dtstr)
3097 self.assertEqual(dt, dt_rt)
3099 def test_fromisoformat_datetime_examples(self):
3105 ('2025-01-02', self.theclass(2025, 1, 2, 0, 0)),
3106 ('2025-01-02T03', self.theclass(2025, 1, 2, 3, 0)),
3107 ('2025-01-02T03:04', self.theclass(2025, 1, 2, 3, 4)),
3108 ('2025-01-02T0304', self.theclass(2025, 1, 2, 3, 4)),
3109 ('2025-01-02T03:04:05', self.theclass(2025, 1, 2, 3, 4, 5)),
3110 ('2025-01-02T030405', self.theclass(2025, 1, 2, 3, 4, 5)),
3112 self.theclass(2025, 1, 2, 3, 4, 5, 600000)),
3114 self.theclass(2025, 1, 2, 3, 4, 5, 600000)),
3116 self.theclass(2025, 1, 2, 3, 4, 5, 678000)),
3118 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3120 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3122 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3124 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3126 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3128 self.theclass(2009, 4, 19, 3, 15, 45, 234500)),
3130 self.theclass(2009, 4, 19, 3, 15, 45, 123456)),
3132 self.theclass(2025, 1, 2, 3, 4, 5, 678000)),
3133 ('20250102', self.theclass(2025, 1, 2, 0, 0)),
3134 ('20250102T03', self.theclass(2025, 1, 2, 3, 0)),
3135 ('20250102T03:04', self.theclass(2025, 1, 2, 3, 4)),
3136 ('20250102T03:04:05', self.theclass(2025, 1, 2, 3, 4, 5)),
3137 ('20250102T030405', self.theclass(2025, 1, 2, 3, 4, 5)),
3139 self.theclass(2025, 1, 2, 3, 4, 5, 600000)),
3141 self.theclass(2025, 1, 2, 3, 4, 5, 600000)),
3143 self.theclass(2025, 1, 2, 3, 4, 5, 678000)),
3145 self.theclass(2025, 1, 2, 3, 4, 5, 678000)),
3147 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3149 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3151 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3153 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3154 ('2022W01', self.theclass(2022, 1, 3)),
3155 ('2022W52520', self.theclass(2022, 12, 26, 20, 0)),
3156 ('2022W527520', self.theclass(2023, 1, 1, 20, 0)),
3157 ('2026W01516', self.theclass(2025, 12, 29, 16, 0)),
3158 ('2026W013516', self.theclass(2025, 12, 31, 16, 0)),
3159 ('2025W01503', self.theclass(2024, 12, 30, 3, 0)),
3160 ('2025W014503', self.theclass(2025, 1, 2, 3, 0)),
3161 ('2025W01512', self.theclass(2024, 12, 30, 12, 0)),
3162 ('2025W014512', self.theclass(2025, 1, 2, 12, 0)),
3163 ('2025W014T121431', self.theclass(2025, 1, 2, 12, 14, 31)),
3164 ('2026W013T162100', self.theclass(2025, 12, 31, 16, 21)),
3165 ('2026W013 162100', self.theclass(2025, 12, 31, 16, 21)),
3166 ('2022W527T202159', self.theclass(2023, 1, 1, 20, 21, 59)),
3167 ('2022W527 202159', self.theclass(2023, 1, 1, 20, 21, 59)),
3168 ('2025W014 121431', self.theclass(2025, 1, 2, 12, 14, 31)),
3169 ('2025W014T030405', self.theclass(2025, 1, 2, 3, 4, 5)),
3170 ('2025W014 030405', self.theclass(2025, 1, 2, 3, 4, 5)),
3171 ('2020-W53-6T03:04:05', self.theclass(2021, 1, 2, 3, 4, 5)),
3172 ('2020W537 03:04:05', self.theclass(2021, 1, 3, 3, 4, 5)),
3173 ('2025-W01-4T03:04:05', self.theclass(2025, 1, 2, 3, 4, 5)),
3175 self.theclass(2025, 1, 2, 3, 4, 5, 678901)),
3176 ('2025-W01-4T12:14:31', self.theclass(2025, 1, 2, 12, 14, 31)),
3178 self.theclass(2025, 1, 2, 12, 14, 31, 12345)),
3179 ('2026-W01-3T16:21:00', self.theclass(2025, 12, 31, 16, 21)),
3180 ('2026-W01-3T16:21:00.000000', self.theclass(2025, 12, 31, 16, 21)),
3182 self.theclass(2023, 1, 1, 20, 21, 59)),
3184 self.theclass(2023, 1, 1, 20, 21, 59, 999999)),
3186 self.theclass(2024, 12, 30, 3, 0, tzinfo=UTC)),
3188 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3190 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3192 self.theclass(2025, 1, 2, 3, 4, 5, 600000, tzinfo=UTC)),
3194 self.theclass(2000, 1, 1, 0, 0, tzinfo=timezone(timedelta(hours=21)))),
3196 self.theclass(2025, 1, 2, 3, 5, 6,
3199 self.theclass(2025, 1, 2, 3, 5, 6,
3202 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3204 self.theclass(2025, 1, 2, 3, 5, 6,
3207 self.theclass(2025, 1, 2, 3, 5, 6,
3210 self.theclass(2020, 1, 1, 3, 5, 7, 123457, tzinfo=EST)),
3212 self.theclass(2020, 1, 1, 3, 5, 7, 123457, tzinfo=EST)),
3214 self.theclass(2020, 6, 1, 4, 5, 6, 111111, tzinfo=EDT)),
3216 self.theclass(2020, 6, 1, 4, 5, 6, 111111, tzinfo=EDT)),
3218 self.theclass(2021, 10, 31, 1, 30, tzinfo=BST)),
3220 self.theclass(2021, 10, 31, 1, 30, tzinfo=BST)),
3222 self.theclass(2025, 1, 2, 3, 4, 5, 600000, tzinfo=UTC)),
3224 self.theclass(2025, 1, 2, 3, 4, 5, 678000,
3229 with self.subTest(input_str=input_str):
3230 actual = self.theclass.fromisoformat(input_str)
3231 self.assertEqual(actual, expected)
3233 def test_fromisoformat_fails_datetime(self):
3265 with self.subTest(bad_str=bad_str):
3266 with self.assertRaises(ValueError):
3267 self.theclass.fromisoformat(bad_str)
3269 def test_fromisoformat_fails_surrogate(self):
3274 with self.assertRaisesRegex(ValueError, re.escape(repr(dtstr))):
3275 self.theclass.fromisoformat(dtstr)
3277 def test_fromisoformat_utc(self):
3279 dt = self.theclass.fromisoformat(dt_str)
3281 self.assertIs(dt.tzinfo, timezone.utc)
3283 def test_fromisoformat_subclass(self):
3284 class DateTimeSubclass(self.theclass):
3292 self.assertEqual(dt, dt_rt)
3293 self.assertIsInstance(dt_rt, DateTimeSubclass)
3300 def test_roundtrip(self):
3310 def test_basic_attributes(self):
3311 t = self.theclass(12, 0)
3312 self.assertEqual(t.hour, 12)
3313 self.assertEqual(t.minute, 0)
3314 self.assertEqual(t.second, 0)
3315 self.assertEqual(t.microsecond, 0)
3317 def test_basic_attributes_nonzero(self):
3320 t = self.theclass(12, 59, 59, 8000)
3321 self.assertEqual(t.hour, 12)
3322 self.assertEqual(t.minute, 59)
3323 self.assertEqual(t.second, 59)
3324 self.assertEqual(t.microsecond, 8000)
3326 def test_roundtrip(self):
3327 t = self.theclass(1, 2, 3, 4)
3331 self.assertTrue(s.startswith('datetime.'))
3334 self.assertEqual(t, t2)
3337 t2 = self.theclass(t.hour, t.minute, t.second,
3339 self.assertEqual(t, t2)
3341 def test_comparing(self):
3343 t1 = self.theclass(*args)
3344 t2 = self.theclass(*args)
3345 self.assertEqual(t1, t2)
3346 self.assertTrue(t1 <= t2)
3347 self.assertTrue(t1 >= t2)
3348 self.assertFalse(t1 != t2)
3349 self.assertFalse(t1 < t2)
3350 self.assertFalse(t1 > t2)
3355 t2 = self.theclass(*newargs) # this is larger than t1
3356 self.assertTrue(t1 < t2)
3357 self.assertTrue(t2 > t1)
3358 self.assertTrue(t1 <= t2)
3359 self.assertTrue(t2 >= t1)
3360 self.assertTrue(t1 != t2)
3361 self.assertTrue(t2 != t1)
3362 self.assertFalse(t1 == t2)
3363 self.assertFalse(t2 == t1)
3364 self.assertFalse(t1 > t2)
3365 self.assertFalse(t2 < t1)
3366 self.assertFalse(t1 >= t2)
3367 self.assertFalse(t2 <= t1)
3370 self.assertEqual(t1 == badarg, False)
3371 self.assertEqual(t1 != badarg, True)
3372 self.assertEqual(badarg == t1, False)
3373 self.assertEqual(badarg != t1, True)
3375 self.assertRaises(TypeError, lambda: t1 <= badarg)
3376 self.assertRaises(TypeError, lambda: t1 < badarg)
3377 self.assertRaises(TypeError, lambda: t1 > badarg)
3378 self.assertRaises(TypeError, lambda: t1 >= badarg)
3379 self.assertRaises(TypeError, lambda: badarg <= t1)
3380 self.assertRaises(TypeError, lambda: badarg < t1)
3381 self.assertRaises(TypeError, lambda: badarg > t1)
3382 self.assertRaises(TypeError, lambda: badarg >= t1)
3384 def test_bad_constructor_arguments(self):
3386 self.theclass(0, 0) # no exception
3387 self.theclass(23, 0) # no exception
3388 self.assertRaises(ValueError, self.theclass, -1, 0)
3389 self.assertRaises(ValueError, self.theclass, 24, 0)
3391 self.theclass(23, 0) # no exception
3392 self.theclass(23, 59) # no exception
3393 self.assertRaises(ValueError, self.theclass, 23, -1)
3394 self.assertRaises(ValueError, self.theclass, 23, 60)
3396 self.theclass(23, 59, 0) # no exception
3397 self.theclass(23, 59, 59) # no exception
3398 self.assertRaises(ValueError, self.theclass, 23, 59, -1)
3399 self.assertRaises(ValueError, self.theclass, 23, 59, 60)
3401 self.theclass(23, 59, 59, 0) # no exception
3402 self.theclass(23, 59, 59, 999999) # no exception
3403 self.assertRaises(ValueError, self.theclass, 23, 59, 59, -1)
3404 self.assertRaises(ValueError, self.theclass, 23, 59, 59, 1000000)
3406 def test_hash_equality(self):
3407 d = self.theclass(23, 30, 17)
3408 e = self.theclass(23, 30, 17)
3409 self.assertEqual(d, e)
3410 self.assertEqual(hash(d), hash(e))
3414 self.assertEqual(len(dic), 1)
3415 self.assertEqual(dic[d], 2)
3416 self.assertEqual(dic[e], 2)
3418 d = self.theclass(0, 5, 17)
3419 e = self.theclass(0, 5, 17)
3420 self.assertEqual(d, e)
3421 self.assertEqual(hash(d), hash(e))
3425 self.assertEqual(len(dic), 1)
3426 self.assertEqual(dic[d], 2)
3427 self.assertEqual(dic[e], 2)
3429 def test_isoformat(self):
3430 t = self.theclass(4, 5, 1, 123)
3431 self.assertEqual(t.isoformat(), "04:05:01.000123")
3432 self.assertEqual(t.isoformat(), str(t))
3434 t = self.theclass()
3435 self.assertEqual(t.isoformat(), "00:00:00")
3436 self.assertEqual(t.isoformat(), str(t))
3438 t = self.theclass(microsecond=1)
3439 self.assertEqual(t.isoformat(), "00:00:00.000001")
3440 self.assertEqual(t.isoformat(), str(t))
3442 t = self.theclass(microsecond=10)
3443 self.assertEqual(t.isoformat(), "00:00:00.000010")
3444 self.assertEqual(t.isoformat(), str(t))
3446 t = self.theclass(microsecond=100)
3447 self.assertEqual(t.isoformat(), "00:00:00.000100")
3448 self.assertEqual(t.isoformat(), str(t))
3450 t = self.theclass(microsecond=1000)
3451 self.assertEqual(t.isoformat(), "00:00:00.001000")
3452 self.assertEqual(t.isoformat(), str(t))
3454 t = self.theclass(microsecond=10000)
3455 self.assertEqual(t.isoformat(), "00:00:00.010000")
3456 self.assertEqual(t.isoformat(), str(t))
3458 t = self.theclass(microsecond=100000)
3459 self.assertEqual(t.isoformat(), "00:00:00.100000")
3460 self.assertEqual(t.isoformat(), str(t))
3462 t = self.theclass(hour=12, minute=34, second=56, microsecond=123456)
3463 self.assertEqual(t.isoformat(timespec='hours'), "12")
3464 self.assertEqual(t.isoformat(timespec='minutes'), "12:34")
3465 self.assertEqual(t.isoformat(timespec='seconds'), "12:34:56")
3466 self.assertEqual(t.isoformat(timespec='milliseconds'), "12:34:56.123")
3467 self.assertEqual(t.isoformat(timespec='microseconds'), "12:34:56.123456")
3468 self.assertEqual(t.isoformat(timespec='auto'), "12:34:56.123456")
3469 self.assertRaises(ValueError, t.isoformat, timespec='monkey')
3471 self.assertRaises(ValueError, t.isoformat, timespec='\ud800')
3473 t = self.theclass(hour=12, minute=34, second=56, microsecond=999500)
3474 self.assertEqual(t.isoformat(timespec='milliseconds'), "12:34:56.999")
3476 t = self.theclass(hour=12, minute=34, second=56, microsecond=0)
3477 self.assertEqual(t.isoformat(timespec='milliseconds'), "12:34:56.000")
3478 self.assertEqual(t.isoformat(timespec='microseconds'), "12:34:56.000000")
3479 self.assertEqual(t.isoformat(timespec='auto'), "12:34:56")
3481 def test_isoformat_timezone(self):
3502 t_base = self.theclass(12, 37, 9)
3508 with self.subTest(tzi=tzi):
3511 def test_1653736(self):
3513 t = self.theclass(second=1)
3514 self.assertRaises(TypeError, t.isoformat, foo=3)
3516 def test_strftime(self):
3517 t = self.theclass(1, 2, 3, 4)
3518 self.assertEqual(t.strftime('%H %M %S %f'), "01 02 03 000004")
3520 self.assertEqual(t.strftime("'%z' '%Z'"), "'' ''")
3528 def test_format(self):
3529 t = self.theclass(1, 2, 3, 4)
3530 self.assertEqual(t.__format__(''), str(t))
3532 with self.assertRaisesRegex(TypeError, 'must be str, not int'):
3536 class A(self.theclass):
3537 def __str__(self):
3540 self.assertEqual(a.__format__(''), 'A')
3543 class B(self.theclass):
3544 def strftime(self, format_spec):
3547 self.assertEqual(b.__format__(''), str(t))
3551 self.assertEqual(t.__format__(fmt), t.strftime(fmt))
3552 self.assertEqual(a.__format__(fmt), t.strftime(fmt))
3553 self.assertEqual(b.__format__(fmt), 'B')
3555 def test_str(self):
3556 self.assertEqual(str(self.theclass(1, 2, 3, 4)), "01:02:03.000004")
3557 self.assertEqual(str(self.theclass(10, 2, 3, 4000)), "10:02:03.004000")
3558 self.assertEqual(str(self.theclass(0, 2, 3, 400000)), "00:02:03.400000")
3559 self.assertEqual(str(self.theclass(12, 2, 3, 0)), "12:02:03")
3560 self.assertEqual(str(self.theclass(23, 15, 0, 0)), "23:15:00")
3562 def test_repr(self):
3563 name = 'datetime.' + self.theclass.__name__
3564 self.assertEqual(repr(self.theclass(1, 2, 3, 4)),
3566 self.assertEqual(repr(self.theclass(10, 2, 3, 4000)),
3568 self.assertEqual(repr(self.theclass(0, 2, 3, 400000)),
3570 self.assertEqual(repr(self.theclass(12, 2, 3, 0)),
3572 self.assertEqual(repr(self.theclass(23, 15, 0, 0)),
3575 def test_resolution_info(self):
3576 self.assertIsInstance(self.theclass.min, self.theclass)
3577 self.assertIsInstance(self.theclass.max, self.theclass)
3578 self.assertIsInstance(self.theclass.resolution, timedelta)
3579 self.assertTrue(self.theclass.max > self.theclass.min)
3581 def test_pickling(self):
3583 orig = self.theclass(*args)
3587 self.assertEqual(orig, derived)
3588 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
3590 def test_pickling_subclass_time(self):
3596 self.assertEqual(orig, derived)
3597 self.assertTrue(isinstance(derived, SubclassTime))
3599 def test_compat_unpickle(self):
3615 with self.subTest(i=i):
3616 expected = self.theclass(*args)
3619 self.assertEqual(derived, expected)
3621 def test_bool(self):
3623 cls = self.theclass
3624 self.assertTrue(cls(1))
3625 self.assertTrue(cls(0, 1))
3626 self.assertTrue(cls(0, 0, 1))
3627 self.assertTrue(cls(0, 0, 0, 1))
3628 self.assertTrue(cls(0))
3629 self.assertTrue(cls())
3631 def test_replace(self):
3632 cls = self.theclass
3635 self.assertEqual(base, base.replace())
3646 self.assertEqual(expected, got)
3651 self.assertRaises(ValueError, base.replace, hour=24)
3652 self.assertRaises(ValueError, base.replace, minute=-1)
3653 self.assertRaises(ValueError, base.replace, second=100)
3654 self.assertRaises(ValueError, base.replace, microsecond=1000000)
3656 def test_subclass_replace(self):
3657 class TimeSubclass(self.theclass):
3661 self.assertIs(type(ctime.replace(hour=10)), TimeSubclass)
3663 def test_subclass_time(self):
3665 class C(self.theclass):
3671 result = self.theclass.__new__(cls, *args, **temp)
3675 def newmeth(self, start):
3676 return start + self.hour + self.second
3680 dt1 = self.theclass(*args)
3683 self.assertEqual(dt2.__class__, C)
3684 self.assertEqual(dt2.theAnswer, 42)
3685 self.assertEqual(dt2.extra, 7)
3686 self.assertEqual(dt1.isoformat(), dt2.isoformat())
3687 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)
3689 def test_backdoor_resistance(self):
3693 self.assertRaises(TypeError, self.theclass,
3696 with self.assertRaisesRegex(TypeError, '^bad tzinfo state arg$'):
3697 self.theclass(bytes([1] * len(base)), 'EST')
3704 def test_argument_passing(self):
3705 cls = self.theclass
3708 def tzname(self, dt): return dt and "real" or "none"
3709 def utcoffset(self, dt):
3716 self.assertEqual(obj.tzname(), expected)
3719 self.assertEqual(obj.utcoffset(), expected)
3720 self.assertEqual(obj.dst(), expected)
3722 def test_bad_tzinfo_classes(self):
3723 cls = self.theclass
3724 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=12)
3727 def __init__(self): pass
3728 def utcoffset(self, dt): pass
3729 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=NiceTry)
3732 def __init__(self): pass
3733 def utcoffset(self, dt): pass
3736 self.assertIs(t.tzinfo, b)
3738 def test_utc_offset_out_of_bounds(self):
3740 def __init__(self, offset):
3741 self.offset = timedelta(minutes=offset)
3742 def utcoffset(self, dt):
3743 return self.offset
3745 cls = self.theclass
3762 self.assertEqual(str(t), "01:02:03" + tag)
3764 self.assertRaises(ValueError, str, t)
3766 def test_tzinfo_classes(self):
3767 cls = self.theclass
3769 def utcoffset(self, dt): return None
3770 def dst(self, dt): return None
3771 def tzname(self, dt): return None
3775 self.assertIsNone(t.utcoffset())
3776 self.assertIsNone(t.dst())
3777 self.assertIsNone(t.tzname())
3780 def utcoffset(self, dt): return timedelta(minutes=-1439)
3781 def dst(self, dt): return timedelta(minutes=1439)
3782 def tzname(self, dt): return "aname"
3784 self.assertEqual(t.utcoffset(), timedelta(minutes=-1439))
3785 self.assertEqual(t.dst(), timedelta(minutes=1439))
3786 self.assertEqual(t.tzname(), "aname")
3790 def utcoffset(self, dt): return "aname"
3791 def dst(self, dt): return 7
3792 def tzname(self, dt): return 0
3794 self.assertRaises(TypeError, t.utcoffset)
3795 self.assertRaises(TypeError, t.dst)
3796 self.assertRaises(TypeError, t.tzname)
3800 def utcoffset(self, dt): return timedelta(hours=-24)
3801 def dst(self, dt): return timedelta(hours=24)
3803 self.assertRaises(ValueError, t.utcoffset)
3804 self.assertRaises(ValueError, t.dst)
3808 def utcoffset(self, dt): return timedelta(microseconds=61)
3809 def dst(self, dt): return timedelta(microseconds=-81)
3811 self.assertEqual(t.utcoffset(), timedelta(microseconds=61))
3812 self.assertEqual(t.dst(), timedelta(microseconds=-81))
3814 def test_aware_compare(self):
3815 cls = self.theclass
3820 def utcoffset(self, t):
3837 self.assertEqual(got, expected)
3859 self.assertEqual(got, expected)
3866 def test_empty(self):
3867 t = self.theclass()
3868 self.assertEqual(t.hour, 0)
3869 self.assertEqual(t.minute, 0)
3870 self.assertEqual(t.second, 0)
3871 self.assertEqual(t.microsecond, 0)
3872 self.assertIsNone(t.tzinfo)
3874 def test_zones(self):
3884 self.assertEqual(t1.tzinfo, est)
3885 self.assertEqual(t2.tzinfo, utc)
3886 self.assertEqual(t3.tzinfo, met)
3887 self.assertIsNone(t4.tzinfo)
3888 self.assertEqual(t5.tzinfo, utc)
3890 self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
3891 self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
3892 self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
3893 self.assertIsNone(t4.utcoffset())
3894 self.assertRaises(TypeError, t1.utcoffset, "no args")
3896 self.assertEqual(t1.tzname(), "EST")
3897 self.assertEqual(t2.tzname(), "UTC")
3898 self.assertEqual(t3.tzname(), "MET")
3899 self.assertIsNone(t4.tzname())
3900 self.assertRaises(TypeError, t1.tzname, "no args")
3902 self.assertEqual(t1.dst(), timedelta(minutes=1))
3903 self.assertEqual(t2.dst(), timedelta(minutes=-2))
3904 self.assertEqual(t3.dst(), timedelta(minutes=3))
3905 self.assertIsNone(t4.dst())
3906 self.assertRaises(TypeError, t1.dst, "no args")
3908 self.assertEqual(hash(t1), hash(t2))
3909 self.assertEqual(hash(t1), hash(t3))
3910 self.assertEqual(hash(t2), hash(t3))
3912 self.assertEqual(t1, t2)
3913 self.assertEqual(t1, t3)
3914 self.assertEqual(t2, t3)
3915 self.assertNotEqual(t4, t5) # mixed tz-aware & naive
3916 self.assertRaises(TypeError, lambda: t4 < t5) # mixed tz-aware & naive
3917 self.assertRaises(TypeError, lambda: t5 < t4) # mixed tz-aware & naive
3919 self.assertEqual(str(t1), "07:47:00-05:00")
3920 self.assertEqual(str(t2), "12:47:00+00:00")
3921 self.assertEqual(str(t3), "13:47:00+01:00")
3922 self.assertEqual(str(t4), "00:00:00.000040")
3923 self.assertEqual(str(t5), "00:00:00.000040+00:00")
3925 self.assertEqual(t1.isoformat(), "07:47:00-05:00")
3926 self.assertEqual(t2.isoformat(), "12:47:00+00:00")
3927 self.assertEqual(t3.isoformat(), "13:47:00+01:00")
3928 self.assertEqual(t4.isoformat(), "00:00:00.000040")
3929 self.assertEqual(t5.isoformat(), "00:00:00.000040+00:00")
3932 self.assertEqual(repr(t1), d + "(7, 47, tzinfo=est)")
3933 self.assertEqual(repr(t2), d + "(12, 47, tzinfo=utc)")
3934 self.assertEqual(repr(t3), d + "(13, 47, tzinfo=met)")
3935 self.assertEqual(repr(t4), d + "(0, 0, 0, 40)")
3936 self.assertEqual(repr(t5), d + "(0, 0, 0, 40, tzinfo=utc)")
3938 self.assertEqual(t1.strftime("%H:%M:%S %%Z=%Z %%z=%z"),
3940 self.assertEqual(t2.strftime("%H:%M:%S %Z %z"), "12:47:00 UTC +0000")
3941 self.assertEqual(t3.strftime("%H:%M:%S %Z %z"), "13:47:00 MET +0100")
3945 self.assertEqual(t1.strftime("%H:%M %%Z='%Z' %%z='%z'"),
3951 def tzname(self, dt): return self.tz
3953 self.assertEqual(t.strftime("%H:%M:%S"), "02:03:04")
3954 self.assertRaises(TypeError, t.strftime, "%Z")
3957 if '_Fast' in self.__class__.__name__:
3959 self.assertRaises(ValueError, t.strftime, "%Z")
3961 def test_hash_edge_cases(self):
3963 t1 = self.theclass(0, 1, 2, 3, tzinfo=FixedOffset(1439, ""))
3964 t2 = self.theclass(0, 0, 2, 3, tzinfo=FixedOffset(1438, ""))
3965 self.assertEqual(hash(t1), hash(t2))
3967 t1 = self.theclass(23, 58, 6, 100, tzinfo=FixedOffset(-1000, ""))
3968 t2 = self.theclass(23, 48, 6, 100, tzinfo=FixedOffset(-1010, ""))
3969 self.assertEqual(hash(t1), hash(t2))
3971 def test_pickling(self):
3974 orig = self.theclass(*args)
3978 self.assertEqual(orig, derived)
3979 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
3983 orig = self.theclass(5, 6, 7, tzinfo=tinfo)
3987 self.assertEqual(orig, derived)
3988 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
3989 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
3990 self.assertEqual(derived.tzname(), 'cookie')
3991 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
3993 def test_compat_unpickle(self):
4018 expected = self.theclass(5, 6, 7, 123456, tzinfo=tinfo)
4022 self.assertEqual(derived, expected, repr(data))
4023 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4024 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
4025 self.assertEqual(derived.tzname(), 'cookie')
4027 def test_more_bool(self):
4029 cls = self.theclass
4032 self.assertTrue(t)
4035 self.assertTrue(t)
4038 self.assertTrue(t)
4041 self.assertTrue(t)
4043 def test_replace(self):
4044 cls = self.theclass
4049 self.assertEqual(base, base.replace())
4061 self.assertEqual(expected, got)
4065 self.assertEqual(base.tzname(), "+100")
4067 self.assertIsNone(base2.tzinfo)
4068 self.assertIsNone(base2.tzname())
4072 self.assertEqual(base, base3)
4073 self.assertIs(base.tzinfo, base3.tzinfo)
4077 self.assertRaises(ValueError, base.replace, hour=24)
4078 self.assertRaises(ValueError, base.replace, minute=-1)
4079 self.assertRaises(ValueError, base.replace, second=100)
4080 self.assertRaises(ValueError, base.replace, microsecond=1000000)
4082 def test_mixed_compare(self):
4083 t1 = self.theclass(1, 2, 3)
4084 t2 = self.theclass(1, 2, 3)
4085 self.assertEqual(t1, t2)
4087 self.assertEqual(t1, t2)
4089 self.assertEqual(t1, t2)
4091 self.assertNotEqual(t1, t2)
4095 def __init__(self):
4096 self.offset = timedelta(minutes=22)
4097 def utcoffset(self, t):
4098 self.offset += timedelta(minutes=1)
4099 return self.offset
4104 self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
4105 self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
4106 self.assertEqual(t1, t2)
4110 self.assertTrue(t1 < t2) # t1's offset counter still going up
4112 def test_fromisoformat(self):
4131 t = self.theclass(*ttup, tzinfo=tzi)
4134 with self.subTest(tstr=tstr):
4135 t_rt = self.theclass.fromisoformat(tstr)
4136 self.assertEqual(t, t_rt)
4138 def test_fromisoformat_timezone(self):
4139 base_time = self.theclass(12, 30, 45, 217456)
4159 with self.subTest(tstr=tstr):
4160 t_rt = self.theclass.fromisoformat(tstr)
4163 def test_fromisoformat_timespecs(self):
4184 t = self.theclass(*(t_tuple[0:(1 + ip)]), tzinfo=tzi)
4186 with self.subTest(tstr=tstr):
4187 t_rt = self.theclass.fromisoformat(tstr)
4188 self.assertEqual(t, t_rt)
4190 def test_fromisoformat_fractions(self):
4203 expected = self.theclass(*time_comps)
4204 actual = self.theclass.fromisoformat(time_str)
4206 self.assertEqual(actual, expected)
4208 def test_fromisoformat_time_examples(self):
4210 ('0000', self.theclass(0, 0)),
4211 ('00:00', self.theclass(0, 0)),
4212 ('000000', self.theclass(0, 0)),
4213 ('00:00:00', self.theclass(0, 0)),
4214 ('000000.0', self.theclass(0, 0)),
4215 ('00:00:00.0', self.theclass(0, 0)),
4216 ('000000.000', self.theclass(0, 0)),
4217 ('00:00:00.000', self.theclass(0, 0)),
4218 ('000000.000000', self.theclass(0, 0)),
4219 ('00:00:00.000000', self.theclass(0, 0)),
4220 ('1200', self.theclass(12, 0)),
4221 ('12:00', self.theclass(12, 0)),
4222 ('120000', self.theclass(12, 0)),
4223 ('12:00:00', self.theclass(12, 0)),
4224 ('120000.0', self.theclass(12, 0)),
4225 ('12:00:00.0', self.theclass(12, 0)),
4226 ('120000.000', self.theclass(12, 0)),
4227 ('12:00:00.000', self.theclass(12, 0)),
4228 ('120000.000000', self.theclass(12, 0)),
4229 ('12:00:00.000000', self.theclass(12, 0)),
4230 ('2359', self.theclass(23, 59)),
4231 ('23:59', self.theclass(23, 59)),
4232 ('235959', self.theclass(23, 59, 59)),
4233 ('23:59:59', self.theclass(23, 59, 59)),
4234 ('235959.9', self.theclass(23, 59, 59, 900000)),
4235 ('23:59:59.9', self.theclass(23, 59, 59, 900000)),
4236 ('235959.999', self.theclass(23, 59, 59, 999000)),
4237 ('23:59:59.999', self.theclass(23, 59, 59, 999000)),
4238 ('235959.999999', self.theclass(23, 59, 59, 999999)),
4239 ('23:59:59.999999', self.theclass(23, 59, 59, 999999)),
4240 ('00:00:00Z', self.theclass(0, 0, tzinfo=timezone.utc)),
4241 ('12:00:00+0000', self.theclass(12, 0, tzinfo=timezone.utc)),
4242 ('12:00:00+00:00', self.theclass(12, 0, tzinfo=timezone.utc)),
4244 self.theclass(0, 0, tzinfo=timezone(timedelta(hours=5)))),
4246 self.theclass(0, 0, tzinfo=timezone(timedelta(hours=5, minutes=30)))),
4248 self.theclass(12, 0, tzinfo=timezone(timedelta(hours=-5)))),
4250 self.theclass(12, 0, tzinfo=timezone(timedelta(hours=-5)))),
4252 self.theclass(0, 0, tzinfo=timezone(-timedelta(hours=23, minutes=59, seconds=59, microseconds=999999)))),
4256 with self.subTest(input_str=input_str):
4257 actual = self.theclass.fromisoformat(input_str)
4258 self.assertEqual(actual, expected)
4260 def test_fromisoformat_fails(self):
4288 with self.subTest(bad_str=bad_str):
4289 with self.assertRaises(ValueError):
4290 self.theclass.fromisoformat(bad_str)
4292 def test_fromisoformat_fails_typeerror(self):
4297 with self.assertRaises(TypeError):
4298 self.theclass.fromisoformat(bad_type)
4300 def test_fromisoformat_subclass(self):
4301 class TimeSubclass(self.theclass):
4307 self.assertEqual(tsc, tsc_rt)
4308 self.assertIsInstance(tsc_rt, TimeSubclass)
4310 def test_subclass_timetz(self):
4312 class C(self.theclass):
4318 result = self.theclass.__new__(cls, *args, **temp)
4322 def newmeth(self, start):
4323 return start + self.hour + self.second
4327 dt1 = self.theclass(*args)
4330 self.assertEqual(dt2.__class__, C)
4331 self.assertEqual(dt2.theAnswer, 42)
4332 self.assertEqual(dt2.extra, 7)
4333 self.assertEqual(dt1.utcoffset(), dt2.utcoffset())
4334 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.second - 7)
4342 def test_trivial(self):
4343 dt = self.theclass(1, 2, 3, 4, 5, 6, 7)
4344 self.assertEqual(dt.year, 1)
4345 self.assertEqual(dt.month, 2)
4346 self.assertEqual(dt.day, 3)
4347 self.assertEqual(dt.hour, 4)
4348 self.assertEqual(dt.minute, 5)
4349 self.assertEqual(dt.second, 6)
4350 self.assertEqual(dt.microsecond, 7)
4351 self.assertEqual(dt.tzinfo, None)
4353 def test_even_more_compare(self):
4358 t1 = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
4360 t2 = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
4364 self.assertTrue(t1 < t2)
4365 self.assertTrue(t1 != t2)
4366 self.assertTrue(t2 > t1)
4368 self.assertEqual(t1, t1)
4369 self.assertEqual(t2, t2)
4372 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""))
4373 t2 = self.theclass(2, 1, 1, 3, 13, tzinfo=FixedOffset(3*60+13+2, ""))
4374 self.assertEqual(t1, t2)
4377 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))
4378 self.assertTrue(t1 > t2)
4381 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))
4382 self.assertTrue(t1 < t2)
4385 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
4387 self.assertTrue(t1 > t2)
4390 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
4392 self.assertTrue(t1 > t2)
4395 t2 = self.theclass.min
4396 self.assertNotEqual(t1, t2)
4397 self.assertEqual(t2, t2)
4399 with self.assertRaises(TypeError):
4404 def utcoffset(self, dt): return None
4405 t2 = self.theclass(5, 6, 7, tzinfo=Naive())
4406 self.assertNotEqual(t1, t2)
4407 self.assertEqual(t2, t2)
4411 t1 = self.theclass(5, 6, 7)
4412 self.assertEqual(t1, t2)
4416 def utcoffset(self, dt):
4418 t1 = self.theclass(2, 2, 2, tzinfo=Bogus())
4419 t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))
4420 self.assertRaises(ValueError, lambda: t1 == t2)
4422 def test_pickling(self):
4425 orig = self.theclass(*args)
4429 self.assertEqual(orig, derived)
4430 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
4434 orig = self.theclass(*args, **{'tzinfo': tinfo})
4435 derived = self.theclass(1, 1, 1, tzinfo=FixedOffset(0, "", 0))
4439 self.assertEqual(orig, derived)
4440 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4441 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
4442 self.assertEqual(derived.tzname(), 'cookie')
4443 self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
4445 def test_compat_unpickle(self):
4473 expected = self.theclass(*args, **{'tzinfo': tinfo})
4477 self.assertEqual(derived, expected)
4478 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4479 self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
4480 self.assertEqual(derived.tzname(), 'cookie')
4482 def test_extreme_hashes(self):
4486 t = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
4488 t = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
4493 t = self.theclass(5, 5, 5, tzinfo=FixedOffset(-1440, ""))
4494 self.assertRaises(ValueError, hash, t)
4496 def test_zones(self):
4503 self.assertEqual(t1.tzinfo, est)
4504 self.assertEqual(t2.tzinfo, utc)
4505 self.assertEqual(t3.tzinfo, met)
4506 self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
4507 self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
4508 self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
4509 self.assertEqual(t1.tzname(), "EST")
4510 self.assertEqual(t2.tzname(), "UTC")
4511 self.assertEqual(t3.tzname(), "MET")
4512 self.assertEqual(hash(t1), hash(t2))
4513 self.assertEqual(hash(t1), hash(t3))
4514 self.assertEqual(hash(t2), hash(t3))
4515 self.assertEqual(t1, t2)
4516 self.assertEqual(t1, t3)
4517 self.assertEqual(t2, t3)
4518 self.assertEqual(str(t1), "2002-03-19 07:47:00-05:00")
4519 self.assertEqual(str(t2), "2002-03-19 12:47:00+00:00")
4520 self.assertEqual(str(t3), "2002-03-19 13:47:00+01:00")
4522 self.assertEqual(repr(t1), d + "7, 47, tzinfo=est)")
4523 self.assertEqual(repr(t2), d + "12, 47, tzinfo=utc)")
4524 self.assertEqual(repr(t3), d + "13, 47, tzinfo=met)")
4526 def test_combine(self):
4531 self.assertEqual(dt, datetime(2002, 3, 4, 18, 45, 3, 1234,
4534 def test_extract(self):
4536 dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234, tzinfo=met)
4537 self.assertEqual(dt.date(), date(2002, 3, 4))
4538 self.assertEqual(dt.time(), time(18, 45, 3, 1234))
4539 self.assertEqual(dt.timetz(), time(18, 45, 3, 1234, tzinfo=met))
4541 def test_tz_aware_arithmetic(self):
4542 now = self.theclass.now()
4545 nowaware = self.theclass.combine(now.date(), timeaware)
4546 self.assertIs(nowaware.tzinfo, tz55)
4547 self.assertEqual(nowaware.timetz(), timeaware)
4550 self.assertRaises(TypeError, lambda: now - nowaware)
4551 self.assertRaises(TypeError, lambda: nowaware - now)
4554 self.assertRaises(TypeError, lambda: now + nowaware)
4555 self.assertRaises(TypeError, lambda: nowaware + now)
4556 self.assertRaises(TypeError, lambda: nowaware + nowaware)
4559 self.assertEqual(now - now, timedelta(0))
4560 self.assertEqual(nowaware - nowaware, timedelta(0))
4565 self.assertIs(nowaware.tzinfo, tz55)
4567 self.assertIs(nowawareplus2.tzinfo, tz55)
4568 self.assertEqual(nowawareplus, nowawareplus2)
4573 self.assertIs(diff.tzinfo, tz55)
4574 self.assertEqual(nowaware, diff)
4575 self.assertRaises(TypeError, lambda: delta - nowawareplus)
4576 self.assertEqual(nowawareplus - nowaware, delta)
4582 self.assertIs(nowawareplus.tzinfo, tzr)
4591 self.assertEqual(got, expected)
4594 min = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, "min"))
4595 max = self.theclass(MAXYEAR, 12, 31, 23, 59, 59, 999999,
4598 self.assertEqual(maxdiff, self.theclass.max - self.theclass.min +
4604 self.assertEqual(delta, self.theclass.min - self.theclass.max)
4606 def test_tzinfo_now(self):
4607 meth = self.theclass.now
4614 self.assertIs(another.tzinfo, again.tzinfo)
4615 self.assertEqual(another.utcoffset(), timedelta(minutes=42))
4617 self.assertRaises(TypeError, meth, 16)
4618 self.assertRaises(TypeError, meth, tzinfo=16)
4620 self.assertRaises(TypeError, meth, tinfo=off42)
4622 self.assertRaises(TypeError, meth, off42, off42)
4632 self.assertIs(now.tzinfo, weirdtz)
4641 self.fail("utcnow(), now(tz), or astimezone() may be broken")
4643 def test_tzinfo_fromtimestamp(self):
4645 meth = self.theclass.fromtimestamp
4653 self.assertIs(another.tzinfo, again.tzinfo)
4654 self.assertEqual(another.utcoffset(), timedelta(minutes=42))
4656 self.assertRaises(TypeError, meth, ts, 16)
4657 self.assertRaises(TypeError, meth, ts, tzinfo=16)
4659 self.assertRaises(TypeError, meth, ts, tinfo=off42)
4661 self.assertRaises(TypeError, meth, ts, off42, off42)
4663 self.assertRaises(TypeError, meth)
4676 self.assertEqual(expected, got.replace(tzinfo=None))
4678 def test_tzinfo_utcnow(self):
4679 meth = self.theclass.utcnow
4685 self.assertRaises(TypeError, meth, off42)
4686 self.assertRaises(TypeError, meth, tzinfo=off42)
4688 def test_tzinfo_utcfromtimestamp(self):
4690 meth = self.theclass.utcfromtimestamp
4697 self.assertRaises(TypeError, meth, ts, off42)
4698 self.assertRaises(TypeError, meth, ts, tzinfo=off42)
4700 def test_tzinfo_timetuple(self):
4704 def __init__(self, dstvalue):
4707 self.dstvalue = dstvalue
4708 def dst(self, dt):
4709 return self.dstvalue
4711 cls = self.theclass
4715 self.assertEqual(1, t.tm_year)
4716 self.assertEqual(1, t.tm_mon)
4717 self.assertEqual(1, t.tm_mday)
4718 self.assertEqual(10, t.tm_hour)
4719 self.assertEqual(20, t.tm_min)
4720 self.assertEqual(30, t.tm_sec)
4721 self.assertEqual(0, t.tm_wday)
4722 self.assertEqual(1, t.tm_yday)
4723 self.assertEqual(flag, t.tm_isdst)
4726 self.assertRaises(TypeError, cls(1, 1, 1, tzinfo=DST("x")).timetuple)
4729 self.assertEqual(cls(1,1,1, tzinfo=DST(1439)).timetuple().tm_isdst, 1)
4730 self.assertEqual(cls(1,1,1, tzinfo=DST(-1439)).timetuple().tm_isdst, 1)
4733 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(1440)).timetuple)
4734 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(-1440)).timetuple)
4736 def test_utctimetuple(self):
4738 def __init__(self, dstvalue=0):
4741 self.dstvalue = dstvalue
4742 def dst(self, dt):
4743 return self.dstvalue
4745 cls = self.theclass
4747 self.assertRaises(NotImplementedError,
4751 def __init__(self, uofs, dofs=None):
4752 DST.__init__(self, dofs)
4753 self.uofs = timedelta(minutes=uofs)
4754 def utcoffset(self, dt):
4755 return self.uofs
4760 self.assertEqual(d.year, t.tm_year)
4761 self.assertEqual(d.month, t.tm_mon)
4762 self.assertEqual(d.day, t.tm_mday)
4763 self.assertEqual(11, t.tm_hour) # 20mm + 53mm = 1hn + 13mm
4764 self.assertEqual(13, t.tm_min)
4765 self.assertEqual(d.second, t.tm_sec)
4766 self.assertEqual(d.weekday(), t.tm_wday)
4767 self.assertEqual(d.toordinal() - date(1, 1, 1).toordinal() + 1,
4771 self.assertEqual(0, t.tm_isdst)
4776 self.assertEqual(t[:-1], d.timetuple()[:-1])
4777 self.assertEqual(0, t.tm_isdst)
4780 def utcoffset(self, dt):
4784 self.assertEqual(t[:-1], d.timetuple()[:-1])
4785 self.assertEqual(0, t.tm_isdst)
4788 def utcoffset(self, dt):
4791 self.assertRaises(TypeError, d.utctimetuple)
4798 self.assertEqual(dtz.utctimetuple()[:-1],
4805 self.assertRaises(OverflowError, tiny.utctimetuple)
4809 self.assertRaises(OverflowError, huge.utctimetuple)
4812 self.assertRaises(OverflowError, tiny.utctimetuple)
4814 self.assertRaises(OverflowError, huge.utctimetuple)
4816 def test_tzinfo_isoformat(self):
4822 cls = self.theclass
4831 self.assertEqual(iso, datestr + 'T' + tailstr)
4832 self.assertEqual(iso, d.isoformat('T'))
4833 self.assertEqual(d.isoformat('k'), datestr + 'k' + tailstr)
4834 self.assertEqual(d.isoformat('\u1234'), datestr + '\u1234' + tailstr)
4835 self.assertEqual(str(d), datestr + ' ' + tailstr)
4837 def test_replace(self):
4838 cls = self.theclass
4843 self.assertEqual(base, base.replace())
4858 self.assertEqual(expected, got)
4862 self.assertEqual(base.tzname(), "+100")
4864 self.assertIsNone(base2.tzinfo)
4865 self.assertIsNone(base2.tzname())
4869 self.assertEqual(base, base3)
4870 self.assertIs(base.tzinfo, base3.tzinfo)
4874 self.assertRaises(ValueError, base.replace, year=2001)
4876 def test_more_astimezone(self):
4882 dt = self.theclass.now(tz=f44m)
4883 self.assertIs(dt.tzinfo, f44m)
4885 self.assertRaises(ValueError, dt.astimezone, fnone)
4888 self.assertIs(x.tzinfo, f44m)
4889 self.assertEqual(x.date(), dt.date())
4890 self.assertEqual(x.time(), dt.time())
4894 self.assertIs(got.tzinfo, fm5h)
4895 self.assertEqual(got.utcoffset(), timedelta(hours=-5))
4899 self.assertEqual(got.date(), expected.date())
4900 self.assertEqual(got.time(), expected.time())
4901 self.assertEqual(got.timetz(), expected.timetz())
4902 self.assertIs(got.tzinfo, expected.tzinfo)
4903 self.assertEqual(got, expected)
4906 def test_astimezone_default_utc(self):
4907 dt = self.theclass.now(timezone.utc)
4908 self.assertEqual(dt.astimezone(None), dt)
4909 self.assertEqual(dt.astimezone(), dt)
4914 def test_astimezone_default_eastern(self):
4915 dt = self.theclass(2012, 11, 4, 6, 30, tzinfo=timezone.utc)
4917 self.assertEqual(dt, local)
4918 self.assertEqual(local.strftime("%z %Z"), "-0500 EST")
4919 dt = self.theclass(2012, 11, 4, 5, 30, tzinfo=timezone.utc)
4921 self.assertEqual(dt, local)
4922 self.assertEqual(local.strftime("%z %Z"), "-0400 EDT")
4925 def test_astimezone_default_near_fold(self):
4930 self.assertEqual(t.tzinfo, s.tzinfo)
4932 def test_aware_subtract(self):
4933 cls = self.theclass
4938 def utcoffset(self, t):
4954 self.assertEqual(got, expected)
4974 self.assertEqual(got, expected)
4976 def test_mixed_compare(self):
4979 self.assertEqual(t1, t2)
4981 self.assertEqual(t1, t2)
4983 self.assertEqual(t1, t2)
4985 self.assertNotEqual(t1, t2)
4989 def __init__(self):
4990 self.offset = timedelta(minutes=22)
4991 def utcoffset(self, t):
4992 self.offset += timedelta(minutes=1)
4993 return self.offset
4998 self.assertEqual(t1.utcoffset(), timedelta(minutes=23))
4999 self.assertEqual(t2.utcoffset(), timedelta(minutes=24))
5000 self.assertEqual(t1, t2)
5004 self.assertTrue(t1 < t2) # t1's offset counter still going up
5006 def test_subclass_datetimetz(self):
5008 class C(self.theclass):
5014 result = self.theclass.__new__(cls, *args, **temp)
5018 def newmeth(self, start):
5019 return start + self.hour + self.year
5023 dt1 = self.theclass(*args)
5026 self.assertEqual(dt2.__class__, C)
5027 self.assertEqual(dt2.theAnswer, 42)
5028 self.assertEqual(dt2.extra, 7)
5029 self.assertEqual(dt1.utcoffset(), dt2.utcoffset())
5030 self.assertEqual(dt2.newmeth(-7), dt1.hour + dt1.year - 7)
5054 def __init__(self, hours, reprname, stdname, dstname):
5055 self.stdoffset = timedelta(hours=hours)
5056 self.reprname = reprname
5057 self.stdname = stdname
5058 self.dstname = dstname
5060 def __repr__(self):
5061 return self.reprname
5063 def tzname(self, dt):
5064 if self.dst(dt):
5065 return self.dstname
5067 return self.stdname
5069 def utcoffset(self, dt):
5070 return self.stdoffset + self.dst(dt)
5072 def dst(self, dt):
5077 assert dt.tzinfo is self
5111 def checkinside(self, dt, tz, utc, dston, dstoff):
5112 self.assertEqual(dt.dst(), HOUR)
5115 self.assertEqual(dt.astimezone(tz), dt)
5131 self.assertEqual(there_and_back + HOUR, dt)
5134 self.assertEqual(there_and_back.dst(), ZERO)
5136 self.assertEqual(there_and_back.astimezone(utc),
5140 self.assertEqual(dt, there_and_back)
5155 self.assertEqual(nexthour_tz, dt.replace(hour=1))
5158 self.assertEqual(nexthour_tz, dt.replace(hour=1))
5160 self.assertEqual(nexthour_tz - dt, HOUR)
5163 def checkoutside(self, dt, tz, utc):
5164 self.assertEqual(dt.dst(), ZERO)
5167 self.assertEqual(dt.astimezone(tz), dt)
5172 self.assertEqual(dt, there_and_back)
5174 def convert_between_tz_and_utc(self, tz, utc):
5175 dston = self.dston.replace(tzinfo=tz)
5181 dstoff = self.dstoff.replace(tzinfo=tz)
5188 self.checkinside(dston, tz, utc, dston, dstoff)
5190 self.checkinside(during, tz, utc, dston, dstoff)
5192 self.checkoutside(dstoff, tz, utc)
5194 self.checkoutside(outside, tz, utc)
5196 def test_easy(self):
5198 self.convert_between_tz_and_utc(Eastern, utc_real)
5199 self.convert_between_tz_and_utc(Pacific, utc_real)
5200 self.convert_between_tz_and_utc(Eastern, utc_fake)
5201 self.convert_between_tz_and_utc(Pacific, utc_fake)
5205 self.convert_between_tz_and_utc(Eastern, Pacific)
5206 self.convert_between_tz_and_utc(Pacific, Eastern)
5217 # self.convert_between_tz_and_utc(Eastern, Central) # can't work
5218 # self.convert_between_tz_and_utc(Central, Eastern) # can't work
5220 def test_tricky(self):
5222 fourback = self.dston - timedelta(hours=4)
5232 expected = self.dston.replace(hour=3)
5234 self.assertEqual(expected, got)
5238 sixutc = self.dston.replace(hour=6, tzinfo=utc_real)
5242 expected = self.dston.replace(hour=1)
5244 self.assertEqual(expected, got)
5253 first_std_hour = self.dstoff - timedelta(hours=2) # 23:MM
5262 expectedbase = self.dstoff.replace(hour=tzhour)
5267 self.assertEqual(astz.replace(tzinfo=None), expected)
5271 def test_bogus_dst(self):
5273 def utcoffset(self, dt): return HOUR
5274 def dst(self, dt): return HOUR
5276 now = self.theclass.now().replace(tzinfo=utc_real)
5282 def dst(self, dt): return None
5283 self.assertRaises(ValueError, now.astimezone, notok())
5290 def dst(self, dt):
5295 dt = self.theclass(2001, 1, 1).replace(tzinfo=utc_real)
5296 self.assertRaises(ValueError, dt.astimezone, tricky_notok())
5298 def test_fromutc(self):
5299 self.assertRaises(TypeError, Eastern.fromutc) # not enough args
5301 self.assertRaises(ValueError, Eastern.fromutc, now) # wrong tzinfo
5304 self.assertEqual(enow.tzinfo, Eastern) # has right tzinfo member
5305 self.assertRaises(TypeError, Eastern.fromutc, now, now) # too many args
5306 self.assertRaises(TypeError, Eastern.fromutc, date.today()) # wrong type
5310 def fromutc(self, dt):
5311 return dt + self.stdoffset
5319 start = self.dston.replace(hour=4, tzinfo=Eastern)
5326 self.assertEqual(expected, got)
5330 self.assertEqual(expected, got)
5334 self.assertEqual(expected, got)
5340 start = self.dstoff.replace(hour=4, tzinfo=Eastern)
5345 self.assertEqual(expected, got)
5349 self.assertEqual(expected, got)
5353 self.assertEqual(expected, got)
5364 def test_bug_1028306(self):
5369 self.assertTrue(as_date != as_datetime)
5370 self.assertTrue(as_datetime != as_date)
5371 self.assertFalse(as_date == as_datetime)
5372 self.assertFalse(as_datetime == as_date)
5373 self.assertRaises(TypeError, lambda: as_date < as_datetime)
5374 self.assertRaises(TypeError, lambda: as_datetime < as_date)
5375 self.assertRaises(TypeError, lambda: as_date <= as_datetime)
5376 self.assertRaises(TypeError, lambda: as_datetime <= as_date)
5377 self.assertRaises(TypeError, lambda: as_date > as_datetime)
5378 self.assertRaises(TypeError, lambda: as_datetime > as_date)
5379 self.assertRaises(TypeError, lambda: as_date >= as_datetime)
5380 self.assertRaises(TypeError, lambda: as_datetime >= as_date)
5384 self.assertEqual(as_date.__eq__(as_datetime), True)
5387 self.assertEqual(as_date.__eq__(as_different), False)
5392 self.assertEqual(as_date, date_sc)
5393 self.assertEqual(date_sc, as_date)
5398 self.assertEqual(as_datetime, datetime_sc)
5399 self.assertEqual(datetime_sc, as_datetime)
5401 def test_extra_attributes(self):
5408 with self.assertRaises(AttributeError):
5411 def test_check_arg_types(self):
5413 def __init__(self, value):
5414 self.value = value
5415 def __int__(self):
5416 return self.value
5425 self.assertRaises(TypeError, datetime, xx, 10, 10, 10, 10, 10, 10)
5426 self.assertRaises(TypeError, datetime, 10, xx, 10, 10, 10, 10, 10)
5427 self.assertRaises(TypeError, datetime, 10, 10, xx, 10, 10, 10, 10)
5428 self.assertRaises(TypeError, datetime, 10, 10, 10, xx, 10, 10, 10)
5429 self.assertRaises(TypeError, datetime, 10, 10, 10, 10, xx, 10, 10)
5430 self.assertRaises(TypeError, datetime, 10, 10, 10, 10, 10, xx, 10)
5431 self.assertRaises(TypeError, datetime, 10, 10, 10, 10, 10, 10, xx)
5441 def fromutc(self, dt):
5446 if dt.tzinfo is not self:
5447 raise ValueError("dt.tzinfo is not self")
5475 def __init__(self, hours, reprname, stdname, dstname):
5476 self.stdoffset = timedelta(hours=hours)
5477 self.reprname = reprname
5478 self.stdname = stdname
5479 self.dstname = dstname
5481 def __repr__(self):
5482 return self.reprname
5484 def tzname(self, dt):
5485 if self.dst(dt):
5486 return self.dstname
5488 return self.stdname
5490 def utcoffset(self, dt):
5491 return self.stdoffset + self.dst(dt)
5493 def dst(self, dt):
5498 assert dt.tzinfo is self
5542 def _utc_fold(self):
5543 return [datetime(1941, 6, 23, 21, tzinfo=self), # Mon Jun 23 21:00:00 1941 UTC
5544 datetime(1941, 6, 23, 22, tzinfo=self)] # Mon Jun 23 22:00:00 1941 UTC
5546 def _loc_fold(self):
5547 return [datetime(1941, 6, 23, 23, tzinfo=self), # Mon Jun 23 23:00:00 1941 MSK / CEST
5548 datetime(1941, 6, 24, 0, tzinfo=self)] # Mon Jun 24 00:00:00 1941 CEST
5550 def utcoffset(self, dt):
5551 fold_start, fold_stop = self._loc_fold()
5559 def dst(self, dt):
5560 fold_start, fold_stop = self._loc_fold()
5568 def tzname(self, dt):
5569 fold_start, fold_stop = self._loc_fold()
5577 def fromutc(self, dt):
5579 assert dt.tzinfo is self
5582 fold_start, fold_stop = self._utc_fold()
5593 def test_vilnius_1941_fromutc(self):
5598 self.assertEqual(ldt.strftime("%c %Z%z"),
5600 self.assertEqual(ldt.fold, 0)
5601 self.assertFalse(ldt.dst())
5605 self.assertEqual(ldt.strftime("%c %Z%z"),
5607 self.assertEqual(ldt.fold, 1)
5608 self.assertTrue(ldt.dst())
5612 self.assertEqual(ldt.strftime("%c %Z%z"),
5614 self.assertEqual(ldt.fold, 0)
5615 self.assertTrue(ldt.dst())
5617 def test_vilnius_1941_toutc(self):
5622 self.assertEqual(gdt.strftime("%c %Z"),
5627 self.assertEqual(gdt.strftime("%c %Z"),
5632 self.assertEqual(gdt.strftime("%c %Z"),
5637 self.assertEqual(gdt.strftime("%c %Z"),
5640 def test_constructors(self):
5643 self.assertEqual(t.fold, 1)
5644 self.assertEqual(dt.fold, 1)
5645 with self.assertRaises(TypeError):
5648 def test_member(self):
5651 self.assertEqual(t.fold, 1)
5653 self.assertEqual(t.fold, 1)
5655 def test_replace(self):
5658 self.assertEqual(t.replace(fold=1).fold, 1)
5659 self.assertEqual(dt.replace(fold=1).fold, 1)
5660 self.assertEqual(t.replace(fold=0).fold, 0)
5661 self.assertEqual(dt.replace(fold=0).fold, 0)
5665 self.assertEqual(t.replace(tzinfo=None).fold, 1)
5666 self.assertEqual(dt.replace(tzinfo=None).fold, 1)
5668 with self.assertRaises(ValueError):
5670 with self.assertRaises(ValueError):
5673 with self.assertRaises(TypeError):
5675 with self.assertRaises(TypeError):
5678 def test_comparison(self):
5681 self.assertEqual(t, t.replace(fold=1))
5682 self.assertEqual(dt, dt.replace(fold=1))
5684 def test_hash(self):
5687 self.assertEqual(hash(t), hash(t.replace(fold=1)))
5688 self.assertEqual(hash(dt), hash(dt.replace(fold=1)))
5691 def test_fromtimestamp(self):
5695 self.assertEqual(dt0.fold, 0)
5696 self.assertEqual(dt1.fold, 1)
5699 def test_fromtimestamp_lord_howe(self):
5702 self.skipTest('Australia/Lord_Howe timezone is not supported on this platform')
5710 self.assertEqual(t0, t1)
5711 self.assertEqual(t0.fold, 0)
5712 self.assertEqual(t1.fold, 1)
5714 def test_fromtimestamp_low_fold_detection(self):
5717 self.assertEqual(datetime.fromtimestamp(0).fold, 0)
5720 def test_timestamp(self):
5723 self.assertEqual(dt0.timestamp() + 3600,
5727 def test_timestamp_lord_howe(self):
5730 self.skipTest('Australia/Lord_Howe timezone is not supported on this platform')
5734 self.assertEqual(s0 + 1800, s1)
5737 def test_astimezone(self):
5744 self.assertEqual(adt0.tzname(), 'EDT')
5745 self.assertEqual(adt1.tzname(), 'EST')
5746 self.assertEqual(adt0 + HOUR, adt1)
5748 self.assertEqual(adt0.fold, 0)
5749 self.assertEqual(adt1.fold, 0)
5751 def test_pickle_fold(self):
5758 self.assertEqual(x, y)
5759 self.assertEqual((0 if proto < 4 else x.fold), y.fold)
5761 def test_repr(self):
5764 self.assertEqual(repr(t), 'datetime.time(0, 0, fold=1)')
5765 self.assertEqual(repr(dt),
5768 def test_dst(self):
5772 self.assertEqual(dt_summer.dst(), HOUR)
5773 self.assertEqual(dt_winter.dst(), ZERO)
5775 self.assertEqual(dt_summer.replace(fold=1).dst(), HOUR)
5776 self.assertEqual(dt_winter.replace(fold=1).dst(), ZERO)
5782 self.assertEqual(dt.dst(), HOUR)
5784 self.assertEqual(dt.replace(fold=1).dst(), ZERO)
5790 self.assertEqual(dt.dst(), ZERO)
5792 self.assertEqual(dt.replace(fold=1).dst(), HOUR)
5795 def test_utcoffset(self):
5799 self.assertEqual(dt_summer.utcoffset(), -4 * HOUR)
5800 self.assertEqual(dt_winter.utcoffset(), -5 * HOUR)
5802 self.assertEqual(dt_summer.replace(fold=1).utcoffset(), -4 * HOUR)
5803 self.assertEqual(dt_winter.replace(fold=1).utcoffset(), -5 * HOUR)
5805 def test_fromutc(self):
5811 self.assertEqual(t_summer, u_summer - 4 * HOUR)
5812 self.assertEqual(t_winter, u_winter - 5 * HOUR)
5813 self.assertEqual(t_summer.fold, 0)
5814 self.assertEqual(t_winter.fold, 0)
5821 self.assertEqual(t0, t1)
5822 self.assertEqual(t0.fold, 0)
5823 self.assertEqual(t1.fold, 1)
5827 self.assertEqual((t.day, t.hour), (26, 21))
5831 self.assertEqual((t.day, t.hour), (27, 1))
5836 self.assertEqual((t.day, t.hour), (6, 21))
5838 def test_mixed_compare_regular(self):
5840 self.assertEqual(t, t.astimezone(timezone.utc))
5842 self.assertEqual(t, t.astimezone(timezone.utc))
5844 def test_mixed_compare_fold(self):
5847 self.assertNotEqual(t_fold, t_fold_utc)
5848 self.assertNotEqual(t_fold_utc, t_fold)
5850 def test_mixed_compare_gap(self):
5853 self.assertNotEqual(t_gap, t_gap_utc)
5854 self.assertNotEqual(t_gap_utc, t_gap)
5856 def test_hash_aware(self):
5858 self.assertEqual(hash(t), hash(t.replace(fold=1)))
5861 self.assertEqual(hash(t_fold), hash(t_fold.replace(fold=1)))
5862 self.assertEqual(hash(t_gap), hash(t_gap.replace(fold=1)))
5873 def __init__(self, ut, ti):
5882 self.ut = ut
5883 self.ti = ti
5884 self.lt = self.invert(ut, ti)
5931 self = cls(ut, ti)
5933 return self
5943 def fromutc(self, dt):
5948 if dt.tzinfo is not self:
5949 raise ValueError("dt.tzinfo is not self")
5951 timestamp = ((dt.toordinal() - self.EPOCHORDINAL) * 86400
5956 if timestamp < self.ut[1]:
5957 tti = self.ti[0]
5960 idx = bisect.bisect_right(self.ut, timestamp)
5961 assert self.ut[idx-1] <= timestamp
5962 assert idx == len(self.ut) or timestamp < self.ut[idx]
5963 tti_prev, tti = self.ti[idx-2:idx]
5966 fold = (shift > timedelta(0, timestamp - self.ut[idx-1]))
5973 def _find_ti(self, dt, i):
5974 timestamp = ((dt.toordinal() - self.EPOCHORDINAL) * 86400
5978 lt = self.lt[dt.fold]
5981 return self.ti[max(0, idx - 1)][i]
5983 def utcoffset(self, dt):
5984 return self._find_ti(dt, 0)
5986 def dst(self, dt):
5987 isdst = self._find_ti(dt, 1)
5994 def tzname(self, dt):
5995 return self._find_ti(dt, 2)
6061 def transitions(self):
6062 for (_, prev_ti), (t, ti) in pairs(zip(self.ut, self.ti)):
6066 def nondst_folds(self):
6068 for (_, prev_ti), (t, ti) in pairs(zip(self.ut, self.ti)):
6085 def folds(self):
6086 for t, shift in self.transitions():
6090 def gaps(self):
6091 for t, shift in self.transitions():
6095 def zeros(self):
6096 for t, shift in self.transitions():
6104 def setUp(self):
6106 self.skipTest("Skipping zoneinfo tests on VxWorks")
6108 self.skipTest("Skipping zoneinfo tests on Windows")
6110 self.tz = ZoneInfo.fromname(self.zonename)
6112 self.skipTest("Skipping %s: %s" % (self.zonename, err))
6114 def assertEquivDatetimes(self, a, b):
6115 self.assertEqual((a.replace(tzinfo=None), a.fold, id(a.tzinfo)),
6118 def test_folds(self):
6119 tz = self.tz
6124 self.assertEqual(ldt.fold, 1)
6126 self.assertEquivDatetimes(adt, ldt)
6128 self.assertEqual(ldt.replace(tzinfo=None), udt + utcoffset)
6130 self.assertEquivDatetimes(ldt.astimezone(timezone.utc),
6138 self.assertEqual(ldt.fold, 0)
6140 def test_gaps(self):
6141 tz = self.tz
6147 self.assertEqual(ldt.fold, 0)
6149 self.assertEquivDatetimes(adt, ldt)
6151 self.assertEqual(ldt.replace(tzinfo=None), udt.replace(tzinfo=None) + utcoffset)
6154 self.assertLess(ldt.replace(fold=1).utcoffset(),
6161 self.assertEqual(ldt.fold, 0)
6166 def test_system_transitions(self):
6167 if ('Riyadh8' in self.zonename or
6174 self.zonename.startswith('right/')):
6175 self.skipTest("Skipping %s" % self.zonename)
6176 tz = self.tz
6178 os.environ['TZ'] = self.zonename
6193 self.assertEquivDatetimes(sdt, tzdt)
6195 self.assertEqual(s, s1)
6201 self.assertEqual(ts0, s0 + ss / 2)
6202 self.assertEqual(ts1, s0 - ss / 2)
6212 def __init__(self):
6230 def setUp(self):
6232 if self.__class__.__name__.endswith('Pure'):
6233 self.skipTest('Not relevant in pure Python')
6239 def test_utc_capi(self):
6243 with self.subTest(use_macro=use_macro):
6244 self.assertIs(capi_utc, timezone.utc)
6246 def test_timezones_capi(self):
6259 with self.subTest(name=name):
6260 self.assertEqual(tz_act, tz_exp)
6265 self.assertEqual(dt1, dt2)
6266 self.assertEqual(dt1.tzname(), dt2.tzname())
6270 self.assertEqual(dt1.astimezone(timezone.utc), dt_utc)
6272 def test_PyDateTime_DELTA_GET(self):
6279 with self.subTest(cls=klass, date=args):
6282 self.assertEqual(days, d.days)
6283 self.assertEqual(seconds, d.seconds)
6284 self.assertEqual(microseconds, d.microseconds)
6286 def test_PyDateTime_GET(self):
6293 with self.subTest(cls=klass, date=args):
6296 self.assertEqual(year, d.year)
6297 self.assertEqual(month, d.month)
6298 self.assertEqual(day, d.day)
6300 def test_PyDateTime_DATE_GET(self):
6309 with self.subTest(cls=klass, date=args):
6313 self.assertEqual(hour, d.hour)
6314 self.assertEqual(minute, d.minute)
6315 self.assertEqual(second, d.second)
6316 self.assertEqual(microsecond, d.microsecond)
6317 self.assertIs(tzinfo, d.tzinfo)
6319 def test_PyDateTime_TIME_GET(self):
6327 with self.subTest(cls=klass, date=args):
6331 self.assertEqual(hour, d.hour)
6332 self.assertEqual(minute, d.minute)
6333 self.assertEqual(second, d.second)
6334 self.assertEqual(microsecond, d.microsecond)
6335 self.assertIs(tzinfo, d.tzinfo)
6337 def test_timezones_offset_zero(self):
6340 with self.subTest(testname="utc0"):
6341 self.assertIs(utc0, timezone.utc)
6343 with self.subTest(testname="utc1"):
6344 self.assertIs(utc1, timezone.utc)
6346 with self.subTest(testname="non_utc"):
6347 self.assertIsNot(non_utc, timezone.utc)
6351 self.assertEqual(non_utc, non_utc_exp)
6356 self.assertEqual(dt1, dt2)
6357 self.assertEqual(dt1.tzname(), dt2.tzname())
6359 def test_check_date(self):
6370 self.assertTrue(is_date(d))
6371 self.assertTrue(is_date(dt))
6372 self.assertTrue(is_date(ds))
6373 self.assertTrue(is_date(d, True))
6376 self.assertFalse(is_date(dt, True))
6377 self.assertFalse(is_date(ds, True))
6384 with self.subTest(arg=arg, exact=exact):
6385 self.assertFalse(is_date(arg, exact))
6387 def test_check_time(self):
6397 self.assertTrue(is_time(t))
6398 self.assertTrue(is_time(ts))
6399 self.assertTrue(is_time(t, True))
6402 self.assertFalse(is_time(ts, True))
6410 with self.subTest(arg=arg, exact=exact):
6411 self.assertFalse(is_time(arg, exact))
6413 def test_check_datetime(self):
6423 self.assertTrue(is_datetime(dt))
6424 self.assertTrue(is_datetime(dts))
6425 self.assertTrue(is_datetime(dt, True))
6428 self.assertFalse(is_datetime(dts, True))
6436 with self.subTest(arg=arg, exact=exact):
6437 self.assertFalse(is_datetime(arg, exact))
6439 def test_check_delta(self):
6449 self.assertTrue(is_timedelta(td))
6450 self.assertTrue(is_timedelta(tds))
6451 self.assertTrue(is_timedelta(td, True))
6454 self.assertFalse(is_timedelta(tds, True))
6462 with self.subTest(arg=arg, exact=exact):
6463 self.assertFalse(is_timedelta(arg, exact))
6465 def test_check_tzinfo(self):
6476 self.assertTrue(is_tzinfo(tzi))
6477 self.assertTrue(is_tzinfo(tz))
6478 self.assertTrue(is_tzinfo(tzis))
6479 self.assertTrue(is_tzinfo(tzi, True))
6482 self.assertFalse(is_tzinfo(tz, True))
6483 self.assertFalse(is_tzinfo(tzis, True))
6491 with self.subTest(arg=arg, exact=exact):
6492 self.assertFalse(is_tzinfo(arg, exact))
6494 def test_date_from_date(self):
6498 with self.subTest(macro=macro):
6505 self.assertEqual(c_api_date, exp_date)
6507 def test_datetime_from_dateandtime(self):
6511 with self.subTest(macro=macro):
6522 self.assertEqual(c_api_date, exp_date)
6524 def test_datetime_from_dateandtimeandfold(self):
6529 with self.subTest(macro=macro, fold=fold):
6541 self.assertEqual(c_api_date, exp_date)
6542 self.assertEqual(c_api_date.fold, exp_date.fold)
6544 def test_time_from_time(self):
6548 with self.subTest(macro=macro):
6556 self.assertEqual(c_api_time, exp_time)
6558 def test_time_from_timeandfold(self):
6563 with self.subTest(macro=macro, fold=fold):
6572 self.assertEqual(c_api_time, exp_time)
6573 self.assertEqual(c_api_time.fold, exp_time.fold)
6575 def test_delta_from_dsu(self):
6579 with self.subTest(macro=macro):
6586 self.assertEqual(c_api_delta, exp_delta)
6588 def test_date_from_timestamp(self):
6592 with self.subTest(macro=macro):
6595 self.assertEqual(d, date(1995, 4, 12))
6597 def test_datetime_from_timestamp(self):
6610 with self.subTest(case=case, macro=macro):
6617 self.assertEqual(dt_orig, dt_rt)