Lines Matching refs:self
57 def setUp(self):
58 self.t = time.time()
60 def test_data_attributes(self):
66 def test_time(self):
69 self.assertFalse(info.monotonic)
70 self.assertTrue(info.adjustable)
72 def test_time_ns_type(self):
74 self.assertIsInstance(ns, int)
78 self.assertLess((sec_ns - ns), 50 ** 6, (sec, ns))
99 def test_clock_realtime(self):
101 self.assertIsInstance(t, float)
107 def test_clock_monotonic(self):
110 self.assertLessEqual(a, b)
116 def test_pthread_getcpuclockid(self):
118 self.assertTrue(type(clk_id) is int)
121 self.assertEqual(clk_id, time.CLOCK_THREAD_CPUTIME_ID)
124 self.assertEqual(clk_id, time.CLOCK_THREAD_CPUTIME_ID)
126 self.assertNotEqual(clk_id, time.CLOCK_THREAD_CPUTIME_ID)
129 self.assertLessEqual(t1, t2)
133 def test_clock_getres(self):
135 self.assertGreater(res, 0.0)
136 self.assertLessEqual(res, 1.0)
140 def test_clock_settime(self):
148 self.assertRaises(OSError,
151 def test_conversions(self):
152 self.assertEqual(time.ctime(self.t),
153 time.asctime(time.localtime(self.t)))
154 self.assertEqual(int(time.mktime(time.localtime(self.t))),
155 int(self.t))
157 def test_sleep(self):
158 self.assertRaises(ValueError, time.sleep, -2)
159 self.assertRaises(ValueError, time.sleep, -1)
162 def test_epoch(self):
167 self.assertEqual(tuple(epoch)[:6], (1970, 1, 1, 0, 0, 0), epoch)
169 def test_strftime(self):
170 tt = time.gmtime(self.t)
178 self.fail('conversion specifier: %r failed.' % format)
180 self.assertRaises(TypeError, time.strftime, b'%S', tt)
182 self.assertRaises(ValueError, time.strftime, '%S\0', tt)
184 def _bounds_checking(self, func):
193 self.assertRaises(ValueError, func,
195 self.assertRaises(ValueError, func,
200 self.assertRaises(ValueError, func,
202 self.assertRaises(ValueError, func,
206 self.assertRaises(ValueError, func,
208 self.assertRaises(ValueError, func,
212 self.assertRaises(ValueError, func,
214 self.assertRaises(ValueError, func,
217 self.assertRaises(ValueError, func,
223 self.assertRaises(ValueError, func,
229 self.assertEqual(func((1900, 1, 1, 0, 0, 0, -1, 1, -1)),
231 self.assertRaises(ValueError, func,
236 self.assertRaises(ValueError, func,
238 self.assertRaises(ValueError, func,
241 def test_strftime_bounding_check(self):
242 self._bounds_checking(lambda tup: time.strftime('', tup))
244 def test_strftime_format_check(self):
257 def test_default_values_for_zero(self):
265 self.assertEqual(expected, result)
268 def test_strptime(self):
271 tt = time.gmtime(self.t)
280 self.fail("conversion specifier %r failed with '%s' input." %
283 def test_strptime_bytes(self):
285 self.assertRaises(TypeError, time.strptime, b'2009', "%Y")
286 self.assertRaises(TypeError, time.strptime, '2009', b'%Y')
288 def test_strptime_exception_context(self):
290 with self.assertRaises(ValueError) as e:
292 self.assertIs(e.exception.__suppress_context__, True)
294 with self.assertRaises(ValueError) as e:
296 self.assertIs(e.exception.__suppress_context__, True)
298 def test_asctime(self):
299 time.asctime(time.gmtime(self.t))
304 self.assertEqual(asc[-len(str(bigyear)):], str(bigyear))
305 self.assertRaises(OverflowError, time.asctime,
307 self.assertRaises(OverflowError, time.asctime,
309 self.assertRaises(TypeError, time.asctime, 0)
310 self.assertRaises(TypeError, time.asctime, ())
311 self.assertRaises(TypeError, time.asctime, (0,) * 10)
313 def test_asctime_bounding_check(self):
314 self._bounds_checking(time.asctime)
319 def test_ctime(self):
321 self.assertEqual(time.ctime(t), 'Sun Sep 16 01:03:52 1973')
323 self.assertEqual(time.ctime(t), 'Sat Jan 1 00:00:00 2000')
332 self.assertEqual(time.ctime(testval)[20:], str(year))
336 def test_tzset(self):
362 self.assertEqual(
365 self.assertEqual(time.daylight, 0)
366 self.assertEqual(time.timezone, 0)
367 self.assertEqual(time.localtime(xmas2002).tm_isdst, 0)
372 self.assertNotEqual(time.gmtime(xmas2002), time.localtime(xmas2002))
373 self.assertEqual(time.tzname, ('EST', 'EDT'))
374 self.assertEqual(len(time.tzname), 2)
375 self.assertEqual(time.daylight, 1)
376 self.assertEqual(time.timezone, 18000)
377 self.assertEqual(time.altzone, 14400)
378 self.assertEqual(time.localtime(xmas2002).tm_isdst, 0)
379 self.assertEqual(len(time.tzname), 2)
384 self.assertNotEqual(time.gmtime(xmas2002), time.localtime(xmas2002))
392 self.assertIn(time.tzname[0], ('AEST' 'EST'), time.tzname[0])
393 self.assertTrue(time.tzname[1] in ('AEDT', 'EDT'), str(time.tzname[1]))
394 self.assertEqual(len(time.tzname), 2)
395 self.assertEqual(time.daylight, 1)
396 self.assertEqual(time.timezone, -36000)
397 self.assertEqual(time.altzone, -39600)
398 self.assertEqual(time.localtime(xmas2002).tm_isdst, 1)
409 def test_insane_timestamps(self):
416 self.assertRaises(OverflowError, func, unreasonable)
418 def test_ctime_without_arg(self):
425 def test_gmtime_without_arg(self):
430 self.assertAlmostEqual(t1, t0, delta=0.2)
432 def test_localtime_without_arg(self):
437 self.assertAlmostEqual(t1, t0, delta=0.2)
439 def test_mktime(self):
447 self.assertEqual(time.mktime(tt), t)
453 def test_mktime_error(self):
457 tt = time.gmtime(self.t)
459 self.assertNotEqual(tzname, 'LMT')
464 self.assertEqual(time.strftime('%Z', tt), tzname)
466 def test_monotonic(self):
471 self.assertGreaterEqual(t2, t1, "times=%s" % times)
479 self.assertGreater(t2, t1)
482 self.assertTrue(0.450 <= dt)
486 self.assertTrue(info.monotonic)
487 self.assertFalse(info.adjustable)
489 def test_perf_counter(self):
495 def test_process_time(self):
502 self.assertLess(stop - start, 0.020)
505 self.assertTrue(info.monotonic)
506 self.assertFalse(info.adjustable)
508 def test_thread_time(self):
511 self.fail("time.thread_time() should be available on %r"
514 self.skipTest("need time.thread_time")
522 self.assertLess(stop - start, 0.020)
525 self.assertTrue(info.monotonic)
526 self.assertFalse(info.adjustable)
530 def test_monotonic_settime(self):
537 self.skipTest(err)
541 self.assertGreaterEqual(t2, t1)
543 def test_localtime_failure(self):
550 self.skipTest("need 64-bit time_t")
555 self.skipTest("unable to find an invalid time_t value")
557 self.assertRaises(OSError, time.localtime, invalid_time_t)
558 self.assertRaises(OSError, time.ctime, invalid_time_t)
561 self.assertRaises(ValueError, time.localtime, float("nan"))
562 self.assertRaises(ValueError, time.ctime, float("nan"))
564 def test_get_clock_info(self):
575 with self.subTest(name=name):
578 self.assertIsInstance(info.implementation, str)
579 self.assertNotEqual(info.implementation, '')
580 self.assertIsInstance(info.monotonic, bool)
581 self.assertIsInstance(info.resolution, float)
583 self.assertGreater(info.resolution, 0.0)
584 self.assertLessEqual(info.resolution, 1.0)
585 self.assertIsInstance(info.adjustable, bool)
587 self.assertRaises(ValueError, time.get_clock_info, 'xxx')
591 def setUp(self):
592 self.oldloc = locale.setlocale(locale.LC_ALL)
594 def tearDown(self):
595 locale.setlocale(locale.LC_ALL, self.oldloc)
597 def test_bug_3061(self):
601 self.skipTest('could not set locale.LC_ALL to fr_FR')
609 def yearstr(self, y):
612 def test_large_year(self):
614 self.assertEqual(self.yearstr(12345), '12345')
615 self.assertEqual(self.yearstr(123456789), '123456789')
629 def yearstr(self, y):
635 def test_4dyear(self):
637 if self._format == '%04d':
638 self.test_year('%04d')
642 self.test_year('%04d', func=year4d)
656 def test_large_year(self):
660 def test_negative(self):
669 def test_year(self, fmt=None, func=None):
670 fmt = fmt or self._format
671 func = func or self.yearstr
672 self.assertEqual(func(1), fmt % 1)
673 self.assertEqual(func(68), fmt % 68)
674 self.assertEqual(func(69), fmt % 69)
675 self.assertEqual(func(99), fmt % 99)
676 self.assertEqual(func(999), fmt % 999)
677 self.assertEqual(func(9999), fmt % 9999)
679 def test_large_year(self):
680 self.assertEqual(self.yearstr(12345).lstrip('+'), '12345')
681 self.assertEqual(self.yearstr(123456789).lstrip('+'), '123456789')
682 self.assertEqual(self.yearstr(TIME_MAXYEAR).lstrip('+'), str(TIME_MAXYEAR))
683 self.assertRaises(OverflowError, self.yearstr, TIME_MAXYEAR + 1)
685 def test_negative(self):
686 self.assertEqual(self.yearstr(-1), self._format % -1)
687 self.assertEqual(self.yearstr(-1234), '-1234')
688 self.assertEqual(self.yearstr(-123456), '-123456')
689 self.assertEqual(self.yearstr(-123456789), str(-123456789))
690 self.assertEqual(self.yearstr(-1234567890), str(-1234567890))
691 self.assertEqual(self.yearstr(TIME_MINYEAR), str(TIME_MINYEAR))
693 self.assertRaises(OverflowError, self.yearstr, TIME_MINYEAR - 1)
694 with self.assertRaises(OverflowError):
695 self.yearstr(-TIME_MAXYEAR - 1)
711 def test_localtime_timezone(self):
715 self.assertTrue(hasattr(lt, "tm_gmtoff"))
716 self.assertTrue(hasattr(lt, "tm_zone"))
721 self.assertTrue(not hasattr(time, "timezone"))
723 self.assertEqual(lt.tm_gmtoff, -[time.timezone, time.altzone][lt.tm_isdst])
725 self.assertTrue(not hasattr(time, "tzname"))
727 self.assertEqual(lt.tm_zone, time.tzname[lt.tm_isdst])
733 self.assertEqual(t, t9)
738 self.assertEqual(new_lt, lt)
739 self.assertEqual(new_lt.tm_gmtoff, lt.tm_gmtoff)
740 self.assertEqual(new_lt.tm_zone, lt.tm_zone)
741 self.assertEqual(new_lt9, lt)
742 self.assertEqual(new_lt.tm_gmtoff, lt.tm_gmtoff)
743 self.assertEqual(new_lt9.tm_zone, lt.tm_zone)
746 def test_strptime_timezone(self):
748 self.assertEqual(t.tm_zone, 'UTC')
750 self.assertEqual(t.tm_gmtoff, 5 * 3600)
753 def test_short_times(self):
760 self.assertIs(lt.tm_gmtoff, None)
761 self.assertIs(lt.tm_zone, None)
771 def setUp(self):
774 self.time_t_min = -2 ** bits
775 self.time_t_max = 2 ** bits - 1
777 def time_t_filter(self, seconds):
778 return (self.time_t_min <= seconds <= self.time_t_max)
780 def _rounding_values(self, use_float):
831 def _check_rounding(self, pytime_converter, expected_func,
849 ns_timestamps = self._rounding_values(use_float)
861 self.fail("Error on timestamp conversion: %s" % debug_info)
862 self.assertEqual(result,
867 ns = self.OVERFLOW_SECONDS * SEC_TO_NS
873 with self.assertRaises(OverflowError, msg=debug_info):
876 def check_int_rounding(self, pytime_converter, expected_func,
878 self._check_rounding(pytime_converter, expected_func,
881 def check_float_rounding(self, pytime_converter, expected_func,
883 self._check_rounding(pytime_converter, expected_func,
886 def decimal_round(self, x):
899 def test_FromSeconds(self):
906 self.check_int_rounding(lambda secs, rnd: PyTime_FromSeconds(secs),
912 with self.assertRaises(TypeError):
915 def test_FromSecondsObject(self):
918 self.check_int_rounding(
922 self.check_float_rounding(
924 lambda ns: self.decimal_round(ns * SEC_TO_NS))
928 with self.assertRaises(ValueError):
931 def test_AsSecondsDouble(self):
940 self.check_int_rounding(lambda ns, rnd: PyTime_AsSecondsDouble(ns),
946 with self.assertRaises(TypeError):
949 def create_decimal_converter(self, denominator):
954 return self.decimal_round(d)
958 def test_AsTimeval(self):
961 us_converter = self.create_decimal_converter(US_TO_NS)
974 seconds_filter = self.time_t_filter
976 self.check_int_rounding(PyTime_AsTimeval,
983 def test_AsTimespec(self):
989 self.check_int_rounding(lambda ns, rnd: PyTime_AsTimespec(ns),
992 value_filter=self.time_t_filter)
996 def test_AsTimeval_clamp(self):
1004 tv_sec_max = self.time_t_max
1005 tv_sec_min = self.time_t_min
1011 us = self.decimal_round(decimal.Decimal(t) / US_TO_NS)
1019 self.assertEqual(ts, (tv_sec, tv_usec))
1023 def test_AsTimespec_clamp(self):
1029 if self.time_t_max < tv_sec:
1030 tv_sec = self.time_t_max
1032 elif tv_sec < self.time_t_min:
1033 tv_sec = self.time_t_min
1035 self.assertEqual(ts, (tv_sec, tv_nsec))
1037 def test_AsMilliseconds(self):
1040 self.check_int_rounding(PyTime_AsMilliseconds,
1041 self.create_decimal_converter(MS_TO_NS),
1044 def test_AsMicroseconds(self):
1047 self.check_int_rounding(PyTime_AsMicroseconds,
1048 self.create_decimal_converter(US_TO_NS),
1060 def test_object_to_time_t(self):
1063 self.check_int_rounding(pytime_object_to_time_t,
1065 value_filter=self.time_t_filter)
1067 self.check_float_rounding(pytime_object_to_time_t,
1068 self.decimal_round,
1069 value_filter=self.time_t_filter)
1071 def create_converter(self, sec_to_unit):
1076 floatpart = self.decimal_round(floatpart)
1086 def test_object_to_timeval(self):
1089 self.check_int_rounding(pytime_object_to_timeval,
1091 value_filter=self.time_t_filter)
1093 self.check_float_rounding(pytime_object_to_timeval,
1094 self.create_converter(SEC_TO_US),
1095 value_filter=self.time_t_filter)
1099 with self.assertRaises(ValueError):
1102 def test_object_to_timespec(self):
1105 self.check_int_rounding(pytime_object_to_timespec,
1107 value_filter=self.time_t_filter)
1109 self.check_float_rounding(pytime_object_to_timespec,
1110 self.create_converter(SEC_TO_NS),
1111 value_filter=self.time_t_filter)
1115 with self.assertRaises(ValueError):
1125 def test_clock_functions(self):
1142 self.assertTrue(hasattr(time, name), f"time.{name} is not available")
1146 self.assertFalse(hasattr(time, name), f"time.{name} is available")