1 from test import test_support

     2 import time

     3 import unittest

     4 

     5 

     6 class TimeTestCase(unittest.TestCase):

     7 

     8     def setUp(self):

     9         self.t = time.time()

    10 

    11     def test_data_attributes(self):

    12         time.altzone

    13         time.daylight

    14         time.timezone

    15         time.tzname

    16 

    17     def test_clock(self):

    18         time.clock()

    19 

    20     def test_conversions(self):

    21         self.assert_(time.ctime(self.t)

    22                      == time.asctime(time.localtime(self.t)))

    23         self.assert_(long(time.mktime(time.localtime(self.t)))

    24                      == long(self.t))

    25 

    26     def test_sleep(self):

    27         time.sleep(1.2)

    28 

    29     def test_strftime(self):

    30         tt = time.gmtime(self.t)

    31         for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',

    32                           'j', 'm', 'M', 'p', 'S',

    33                           'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):

    34             format = ' %' + directive

    35             try:

    36                 time.strftime(format, tt)

    37             except ValueError:

    38                 self.fail('conversion specifier: %r failed.' % format)

    39 

    40     def test_strftime_bounds_checking(self):

    41         # Make sure that strftime() checks the bounds of the various parts

    42         #of the time tuple (0 is valid for *all* values).

    43 

    44         # Check year [1900, max(int)]

    45         self.assertRaises(ValueError, time.strftime, '',

    46                             (1899, 1, 1, 0, 0, 0, 0, 1, -1))

    47         if time.accept2dyear:

    48             self.assertRaises(ValueError, time.strftime, '',

    49                                 (-1, 1, 1, 0, 0, 0, 0, 1, -1))

    50             self.assertRaises(ValueError, time.strftime, '',

    51                                 (100, 1, 1, 0, 0, 0, 0, 1, -1))

    52         # Check month [1, 12] + zero support

    53         self.assertRaises(ValueError, time.strftime, '',

    54                             (1900, -1, 1, 0, 0, 0, 0, 1, -1))

    55         self.assertRaises(ValueError, time.strftime, '',

    56                             (1900, 13, 1, 0, 0, 0, 0, 1, -1))

    57         # Check day of month [1, 31] + zero support

    58         self.assertRaises(ValueError, time.strftime, '',

    59                             (1900, 1, -1, 0, 0, 0, 0, 1, -1))

    60         self.assertRaises(ValueError, time.strftime, '',

    61                             (1900, 1, 32, 0, 0, 0, 0, 1, -1))

    62         # Check hour [0, 23]

    63         self.assertRaises(ValueError, time.strftime, '',

    64                             (1900, 1, 1, -1, 0, 0, 0, 1, -1))

    65         self.assertRaises(ValueError, time.strftime, '',

    66                             (1900, 1, 1, 24, 0, 0, 0, 1, -1))

    67         # Check minute [0, 59]

    68         self.assertRaises(ValueError, time.strftime, '',

    69                             (1900, 1, 1, 0, -1, 0, 0, 1, -1))

    70         self.assertRaises(ValueError, time.strftime, '',

    71                             (1900, 1, 1, 0, 60, 0, 0, 1, -1))

    72         # Check second [0, 61]

    73         self.assertRaises(ValueError, time.strftime, '',

    74                             (1900, 1, 1, 0, 0, -1, 0, 1, -1))

    75         # C99 only requires allowing for one leap second, but Python's docs say

    76         # allow two leap seconds (0..61)

    77         self.assertRaises(ValueError, time.strftime, '',

    78                             (1900, 1, 1, 0, 0, 62, 0, 1, -1))

    79         # No check for upper-bound day of week;

    80         #  value forced into range by a ``% 7`` calculation.

    81         # Start check at -2 since gettmarg() increments value before taking

    82         #  modulo.

    83         self.assertRaises(ValueError, time.strftime, '',

    84                             (1900, 1, 1, 0, 0, 0, -2, 1, -1))

    85         # Check day of the year [1, 366] + zero support

    86         self.assertRaises(ValueError, time.strftime, '',

    87                             (1900, 1, 1, 0, 0, 0, 0, -1, -1))

    88         self.assertRaises(ValueError, time.strftime, '',

    89                             (1900, 1, 1, 0, 0, 0, 0, 367, -1))

    90         # Check daylight savings flag [-1, 1]

    91         self.assertRaises(ValueError, time.strftime, '',

    92                             (1900, 1, 1, 0, 0, 0, 0, 1, -2))

    93         self.assertRaises(ValueError, time.strftime, '',

    94                             (1900, 1, 1, 0, 0, 0, 0, 1, 2))

    95 

    96     def test_default_values_for_zero(self):

    97         # Make sure that using all zeros uses the proper default values.

    98         # No test for daylight savings since strftime() does not change output

    99         # based on its value.

   100         expected = "2000 01 01 00 00 00 1 001"

   101         result = time.strftime("%Y %m %d %H %M %S %w %j", (0,)*9)

   102         self.assertEquals(expected, result)

   103 

   104     def test_strptime(self):

   105         # Should be able to go round-trip from strftime to strptime without

   106         # throwing an exception.

   107         tt = time.gmtime(self.t)

   108         for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',

   109                           'j', 'm', 'M', 'p', 'S',

   110                           'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):

   111             format = '%' + directive

   112             strf_output = time.strftime(format, tt)

   113             try:

   114                 time.strptime(strf_output, format)

   115             except ValueError:

   116                 self.fail("conversion specifier %r failed with '%s' input." %

   117                           (format, strf_output))

   118 

   119     def test_asctime(self):

   120         time.asctime(time.gmtime(self.t))

   121         self.assertRaises(TypeError, time.asctime, 0)

   122 

   123     def test_tzset(self):

   124         if not hasattr(time, "tzset"):

   125             return # Can't test this; don't want the test suite to fail

   126 

   127         from os import environ

   128 

   129         # Epoch time of midnight Dec 25th 2002. Never DST in northern

   130         # hemisphere.

   131         xmas2002 = 1040774400.0

   132 

   133         # These formats are correct for 2002, and possibly future years

   134         # This format is the 'standard' as documented at:

   135         # http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap08.html

   136         # They are also documented in the tzset(3) man page on most Unix

   137         # systems.

   138         eastern = 'EST+05EDT,M4.1.0,M10.5.0'

   139         victoria = 'AEST-10AEDT-11,M10.5.0,M3.5.0'

   140         utc='UTC+0'

   141 

   142         org_TZ = environ.get('TZ',None)

   143         try:

   144             # Make sure we can switch to UTC time and results are correct

   145             # Note that unknown timezones default to UTC.

   146             # Note that altzone is undefined in UTC, as there is no DST

   147             environ['TZ'] = eastern

   148             time.tzset()

   149             environ['TZ'] = utc

   150             time.tzset()

   151             self.failUnlessEqual(

   152                 time.gmtime(xmas2002), time.localtime(xmas2002)

   153                 )

   154             self.failUnlessEqual(time.daylight, 0)

   155             self.failUnlessEqual(time.timezone, 0)

   156             self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 0)

   157 

   158             # Make sure we can switch to US/Eastern

   159             environ['TZ'] = eastern

   160             time.tzset()

   161             self.failIfEqual(time.gmtime(xmas2002), time.localtime(xmas2002))

   162             self.failUnlessEqual(time.tzname, ('EST', 'EDT'))

   163             self.failUnlessEqual(len(time.tzname), 2)

   164             self.failUnlessEqual(time.daylight, 1)

   165             self.failUnlessEqual(time.timezone, 18000)

   166             self.failUnlessEqual(time.altzone, 14400)

   167             self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 0)

   168             self.failUnlessEqual(len(time.tzname), 2)

   169 

   170             # Now go to the southern hemisphere.

   171             environ['TZ'] = victoria

   172             time.tzset()

   173             self.failIfEqual(time.gmtime(xmas2002), time.localtime(xmas2002))

   174             self.failUnless(time.tzname[0] == 'AEST', str(time.tzname[0]))

   175             self.failUnless(time.tzname[1] == 'AEDT', str(time.tzname[1]))

   176             self.failUnlessEqual(len(time.tzname), 2)

   177             self.failUnlessEqual(time.daylight, 1)

   178             self.failUnlessEqual(time.timezone, -36000)

   179             self.failUnlessEqual(time.altzone, -39600)

   180             self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 1)

   181 

   182         finally:

   183             # Repair TZ environment variable in case any other tests

   184             # rely on it.

   185             if org_TZ is not None:

   186                 environ['TZ'] = org_TZ

   187             elif environ.has_key('TZ'):

   188                 del environ['TZ']

   189             time.tzset()

   190 

   191     def test_insane_timestamps(self):

   192         # It's possible that some platform maps time_t to double,

   193         # and that this test will fail there.  This test should

   194         # exempt such platforms (provided they return reasonable

   195         # results!).

   196         for func in time.ctime, time.gmtime, time.localtime:

   197             for unreasonable in -1e200, 1e200:

   198                 self.assertRaises(ValueError, func, unreasonable)

   199 

   200     def test_ctime_without_arg(self):

   201         # Not sure how to check the values, since the clock could tick

   202         # at any time.  Make sure these are at least accepted and

   203         # don't raise errors.

   204         time.ctime()

   205         time.ctime(None)

   206 

   207     def test_gmtime_without_arg(self):

   208         gt0 = time.gmtime()

   209         gt1 = time.gmtime(None)

   210         t0 = time.mktime(gt0)

   211         t1 = time.mktime(gt1)

   212         self.assert_(0 <= (t1-t0) < 0.2)

   213 

   214     def test_localtime_without_arg(self):

   215         lt0 = time.localtime()

   216         lt1 = time.localtime(None)

   217         t0 = time.mktime(lt0)

   218         t1 = time.mktime(lt1)

   219         self.assert_(0 <= (t1-t0) < 0.2)

   220 

   221 def test_main():

   222     test_support.run_unittest(TimeTestCase)

   223 

   224 

   225 if __name__ == "__main__":

   226     test_main()