Esempio n. 1
0
    def test_ValueError(self):
        # Make sure ValueError is raised when match fails or format is bad
        self.assertRaises(ValueError, _strptime._strptime_time, data_string="%d",
                          format="%A")
        for bad_format in ("%", "% ", "%e"):
            try:
                _strptime._strptime_time("2005", bad_format)
            except ValueError:
                continue
            except Exception as err:
                self.fail("'%s' raised %s, not ValueError" %
                            (bad_format, err.__class__.__name__))
            else:
                self.fail("'%s' did not raise ValueError" % bad_format)

        # Ambiguous or incomplete cases using ISO year/week/weekday directives
        # 1. ISO week (%V) is specified, but the year is specified with %Y
        # instead of %G
        with self.assertRaises(ValueError):
            _strptime._strptime("1999 50", "%Y %V")
        # 2. ISO year (%G) and ISO week (%V) are specified, but weekday is not
        with self.assertRaises(ValueError):
            _strptime._strptime("1999 51", "%G %V")
        # 3. ISO year (%G) and weekday are specified, but ISO week (%V) is not
        for w in ('A', 'a', 'w', 'u'):
            with self.assertRaises(ValueError):
                _strptime._strptime("1999 51","%G %{}".format(w))
        # 4. ISO year is specified alone (e.g. time.strptime('2015', '%G'))
        with self.assertRaises(ValueError):
            _strptime._strptime("2015", "%G")
        # 5. Julian/ordinal day (%j) is specified with %G, but not %Y
        with self.assertRaises(ValueError):
            _strptime._strptime("1999 256", "%G %j")
Esempio n. 2
0
 def test_TimeRE_recreation(self):
     # The TimeRE instance should be recreated upon changing the locale.
     locale_info = locale.getlocale(locale.LC_TIME)
     try:
         locale.setlocale(locale.LC_TIME, ('en_US', 'UTF8'))
     except locale.Error:
         self.skipTest('test needs en_US.UTF8 locale')
     try:
         _strptime._strptime_time('10', '%d')
         # Get id of current cache object.
         first_time_re = _strptime._TimeRE_cache
         try:
             # Change the locale and force a recreation of the cache.
             locale.setlocale(locale.LC_TIME, ('de_DE', 'UTF8'))
             _strptime._strptime_time('10', '%d')
             # Get the new cache object's id.
             second_time_re = _strptime._TimeRE_cache
             # They should not be equal.
             self.assertIsNot(first_time_re, second_time_re)
         # Possible test locale is not supported while initial locale is.
         # If this is the case just suppress the exception and fall-through
         # to the resetting to the original locale.
         except locale.Error:
             self.skipTest('test needs de_DE.UTF8 locale')
     # Make sure we don't trample on the locale setting once we leave the
     # test.
     finally:
         locale.setlocale(locale.LC_TIME, locale_info)
Esempio n. 3
0
 def test_new_localetime(self):
     # A new LocaleTime instance should be created when a new TimeRE object
     # is created.
     locale_time_id = _strptime._TimeRE_cache.locale_time
     _strptime._TimeRE_cache.locale_time.lang = "Ni"
     _strptime._strptime_time("10", "%d")
     self.assertIsNot(locale_time_id, _strptime._TimeRE_cache.locale_time)
Esempio n. 4
0
 def test_new_localetime(self):
     # A new LocaleTime instance should be created when a new TimeRE object
     # is created.
     locale_time_id = id(_strptime._TimeRE_cache.locale_time)
     _strptime._TimeRE_cache.locale_time.lang = "Ni"
     _strptime._strptime_time("10", "%d")
     self.failIfEqual(locale_time_id,
                      id(_strptime._TimeRE_cache.locale_time))
Esempio n. 5
0
 def test_caseinsensitive(self):
     # Should handle names case-insensitively.
     strf_output = time.strftime("%B", self.time_tuple)
     self.assertTrue(_strptime._strptime_time(strf_output.upper(), "%B"),
                     "strptime does not handle ALL-CAPS names properly")
     self.assertTrue(_strptime._strptime_time(strf_output.lower(), "%B"),
                     "strptime does not handle lowercase names properly")
     self.assertTrue(_strptime._strptime_time(strf_output.capitalize(), "%B"),
                     "strptime does not handle capword names properly")
Esempio n. 6
0
 def test_strptime_exception_context(self):
     # check that this doesn't chain exceptions needlessly (see #17572)
     with self.assertRaises(ValueError) as e:
         _strptime._strptime_time('', '%D')
     self.assertIs(e.exception.__suppress_context__, True)
     # additional check for IndexError branch (issue #19545)
     with self.assertRaises(ValueError) as e:
         _strptime._strptime_time('19', '%Y %')
     self.assertIs(e.exception.__suppress_context__, True)
Esempio n. 7
0
 def test_ValueError(self):
     # Make sure ValueError is raised when match fails or format is bad
     self.assertRaises(ValueError, _strptime._strptime_time, data_string="%d", format="%A")
     for bad_format in ("%", "% ", "%e"):
         try:
             _strptime._strptime_time("2005", bad_format)
         except ValueError:
             continue
         except Exception, err:
             self.fail("'%s' raised %s, not ValueError" % (bad_format, err.__class__.__name__))
         else:
             self.fail("'%s' did not raise ValueError" % bad_format)
Esempio n. 8
0
 def test_regex_cleanup(self):
     # Make sure cached regexes are discarded when cache becomes "full".
     try:
         del _strptime._regex_cache['%d']
     except KeyError:
         pass
     bogus_key = 0
     while len(_strptime._regex_cache) <= _strptime._CACHE_MAX_SIZE:
         _strptime._regex_cache[bogus_key] = None
         bogus_key += 1
     _strptime._strptime_time("10", "%d")
     self.assertEqual(len(_strptime._regex_cache), 1)
Esempio n. 9
0
 def test_TimeRE_recreation_timezone(self):
     # The TimeRE instance should be recreated upon changing the timezone.
     oldtzname = time.tzname
     tm = _strptime._strptime_time(time.tzname[0], '%Z')
     self.assertEqual(tm.tm_isdst, 0)
     tm = _strptime._strptime_time(time.tzname[1], '%Z')
     self.assertEqual(tm.tm_isdst, 1)
     # Get id of current cache object.
     first_time_re = _strptime._TimeRE_cache
     # Change the timezone and force a recreation of the cache.
     os.environ['TZ'] = 'EST+05EDT,M3.2.0,M11.1.0'
     time.tzset()
     tm = _strptime._strptime_time(time.tzname[0], '%Z')
     self.assertEqual(tm.tm_isdst, 0)
     tm = _strptime._strptime_time(time.tzname[1], '%Z')
     self.assertEqual(tm.tm_isdst, 1)
     # Get the new cache object's id.
     second_time_re = _strptime._TimeRE_cache
     # They should not be equal.
     self.assertIsNot(first_time_re, second_time_re)
     # Make sure old names no longer accepted.
     with self.assertRaises(ValueError):
         _strptime._strptime_time(oldtzname[0], '%Z')
     with self.assertRaises(ValueError):
         _strptime._strptime_time(oldtzname[1], '%Z')
Esempio n. 10
0
 def test_percent(self):
     # Make sure % signs are handled properly
     strf_output = time.strftime("%m %% %Y", self.time_tuple)
     strp_output = _strptime._strptime_time(strf_output, "%m %% %Y")
     self.assertTrue(strp_output[0] == self.time_tuple[0] and
                      strp_output[1] == self.time_tuple[1],
                     "handling of percent sign failed")
Esempio n. 11
0
 def test_defaults(self):
     # Default return value should be (1900, 1, 1, 0, 0, 0, 0, 1, 0)
     defaults = (1900, 1, 1, 0, 0, 0, 0, 1, -1)
     strp_output = _strptime._strptime_time('1', '%m')
     self.assertTrue(strp_output == defaults,
                     "Default values for strptime() are incorrect;"
                     " %s != %s" % (strp_output, defaults))
Esempio n. 12
0
 def helper(self, directive, position):
     """Helper fxn in testing."""
     strf_output = time.strftime("%" + directive, self.time_tuple)
     strp_output = _strptime._strptime_time(strf_output, "%" + directive)
     self.assertTrue(strp_output[position] == self.time_tuple[position],
                     "testing of '%s' directive failed; '%s' -> %s != %s" %
                      (directive, strf_output, strp_output[position],
                       self.time_tuple[position]))
Esempio n. 13
0
 def test_hour(self):
     # Test hour directives
     self.helper('H', 3)
     strf_output = time.strftime("%I %p", self.time_tuple)
     strp_output = _strptime._strptime_time(strf_output, "%I %p")
     self.assertTrue(strp_output[3] == self.time_tuple[3],
                     "testing of '%%I %%p' directive failed; '%s' -> %s != %s" %
                      (strf_output, strp_output[3], self.time_tuple[3]))
Esempio n. 14
0
 def test_escaping(self):
     # Make sure all characters that have regex significance are escaped.
     # Parentheses are in a purposeful order; will cause an error of
     # unbalanced parentheses when the regex is compiled if they are not
     # escaped.
     # Test instigated by bug #796149 .
     need_escaping = ".^$*+?{}\[]|)("
     self.assertTrue(_strptime._strptime_time(need_escaping, need_escaping))
Esempio n. 15
0
 def test_julian_calculation(self):
     # Make sure that when Julian is missing that it is calculated
     format_string = "%Y %m %d %H %M %S %w %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_yday == self.time_tuple.tm_yday,
                     "Calculation of tm_yday failed; %s != %s" %
                      (result.tm_yday, self.time_tuple.tm_yday))
Esempio n. 16
0
 def test_day_of_week_calculation(self):
     # Test that the day of the week is calculated as needed
     format_string = "%Y %m %d %H %S %j %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_wday == self.time_tuple.tm_wday,
                     "Calculation of day of the week failed;"
                      "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday))
Esempio n. 17
0
def strptime(string, format="%a %b %d %H:%M:%S %Y"):
    """strptime(string, format) -> struct_time

    Parse a string to a time tuple according to a format specification.
    See the library reference manual for formatting codes
    (same as strftime())."""

    import _strptime     # from the CPython standard library
    return _strptime._strptime_time(string, format)
Esempio n. 18
0
 def test_day_of_week_calculation(self):
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=409557"):
        return
     # Test that the day of the week is calculated as needed
     format_string = "%Y %m %d %H %S %j %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_wday == self.time_tuple.tm_wday,
                     "Calculation of day of the week failed;"
                      "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday))
 def test_helper(ymd_tuple, test_reason):
     for year_week_format in ("%Y %W", "%Y %U", "%G %V"):
         for weekday_format in ("%w", "%u", "%a", "%A"):
             format_string = year_week_format + " " + weekday_format
             with self.subTest(test_reason, date=ymd_tuple, format=format_string):
                 dt_date = datetime_date(*ymd_tuple)
                 strp_input = dt_date.strftime(format_string)
                 strp_output = _strptime._strptime_time(strp_input, format_string)
                 msg = "%r: %s != %s" % (strp_input, strp_output[7], dt_date.timetuple()[7])
                 self.assertEqual(strp_output[:3], ymd_tuple, msg)
Esempio n. 20
0
 def test_julian_calculation(self):
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=409557"):
        return
     # Make sure that when Julian is missing that it is calculated
     format_string = "%Y %m %d %H %M %S %w %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_yday == self.time_tuple.tm_yday,
                     "Calculation of tm_yday failed; %s != %s" %
                      (result.tm_yday, self.time_tuple.tm_yday))
Esempio n. 21
0
 def test_helper(ymd_tuple, test_reason):
     for directive in ('W', 'U'):
         format_string = "%%Y %%%s %%w" % directive
         dt_date = datetime_date(*ymd_tuple)
         strp_input = dt_date.strftime(format_string)
         strp_output = _strptime._strptime_time(strp_input, format_string)
         self.assertTrue(strp_output[:3] == ymd_tuple,
                 "%s(%s) test failed w/ '%s': %s != %s (%s != %s)" %
                     (test_reason, directive, strp_input,
                         strp_output[:3], ymd_tuple,
                         strp_output[7], dt_date.timetuple()[7]))
Esempio n. 22
0
 def test_year(self):
     # Test that the year is handled properly
     for directive in ('y', 'Y'):
         self.helper(directive, 0)
     # Must also make sure %y values are correct for bounds set by Open Group
     for century, bounds in ((1900, ('69', '99')), (2000, ('00', '68'))):
         for bound in bounds:
             strp_output = _strptime._strptime_time(bound, '%y')
             expected_result = century + int(bound)
             self.assertTrue(strp_output[0] == expected_result,
                             "'y' test failed; passed in '%s' "
                             "and returned '%s'" % (bound, strp_output[0]))
Esempio n. 23
0
 def test_timezone(self):
     # Test timezone directives.
     # When gmtime() is used with %Z, entire result of strftime() is empty.
     # Check for equal timezone names deals with bad locale info when this
     # occurs; first found in FreeBSD 4.4.
     strp_output = _strptime._strptime_time("UTC", "%Z")
     self.assertEqual(strp_output.tm_isdst, 0)
     strp_output = _strptime._strptime_time("GMT", "%Z")
     self.assertEqual(strp_output.tm_isdst, 0)
     time_tuple = time.localtime()
     strf_output = time.strftime("%Z")  #UTC does not have a timezone
     strp_output = _strptime._strptime_time(strf_output, "%Z")
     locale_time = _strptime.LocaleTime()
     if time.tzname[0] != time.tzname[1] or not time.daylight:
         self.assertTrue(strp_output[8] == time_tuple[8],
                         "timezone check failed; '%s' -> %s != %s" %
                          (strf_output, strp_output[8], time_tuple[8]))
     else:
         self.assertTrue(strp_output[8] == -1,
                         "LocaleTime().timezone has duplicate values and "
                          "time.daylight but timezone value not set to -1")
Esempio n. 24
0
 def test_gregorian_calculation(self):
     # Test that Gregorian date can be calculated from Julian day
     format_string = "%Y %H %M %S %w %j %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_year == self.time_tuple.tm_year and
                      result.tm_mon == self.time_tuple.tm_mon and
                      result.tm_mday == self.time_tuple.tm_mday,
                     "Calculation of Gregorian date failed;"
                      "%s-%s-%s != %s-%s-%s" %
                      (result.tm_year, result.tm_mon, result.tm_mday,
                       self.time_tuple.tm_year, self.time_tuple.tm_mon,
                       self.time_tuple.tm_mday))
Esempio n. 25
0
 def test_timezone(self):
     # Test timezone directives.
     # When gmtime() is used with %Z, entire result of strftime() is empty.
     # Check for equal timezone names deals with bad locale info when this
     # occurs; first found in FreeBSD 4.4.
     strp_output = _strptime._strptime_time("UTC", "%Z")
     self.assertEqual(strp_output.tm_isdst, 0)
     strp_output = _strptime._strptime_time("GMT", "%Z")
     self.assertEqual(strp_output.tm_isdst, 0)
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=409557"):
        return
     time_tuple = time.localtime()
     strf_output = time.strftime("%Z")  #UTC does not have a timezone
     strp_output = _strptime._strptime_time(strf_output, "%Z")
     locale_time = _strptime.LocaleTime()
     if time.tzname[0] != time.tzname[1] or not time.daylight:
         self.assertTrue(strp_output[8] == time_tuple[8],
                         "timezone check failed; '%s' -> %s != %s" %
                          (strf_output, strp_output[8], time_tuple[8]))
     else:
         self.assertTrue(strp_output[8] == -1,
                         "LocaleTime().timezone has duplicate values and "
                          "time.daylight but timezone value not set to -1")
Esempio n. 26
0
 def test_helper(ymd_tuple, test_reason):
     for year_week_format in ('%Y %W', '%Y %U', '%G %V'):
         for weekday_format in ('%w', '%u', '%a', '%A'):
             format_string = year_week_format + ' ' + weekday_format
             with self.subTest(test_reason,
                               date=ymd_tuple,
                               format=format_string):
                 dt_date = datetime_date(*ymd_tuple)
                 strp_input = dt_date.strftime(format_string)
                 strp_output = _strptime._strptime_time(strp_input,
                                                        format_string)
                 msg = "%r: %s != %s" % (strp_input,
                                         strp_output[7],
                                         dt_date.timetuple()[7])
                 self.assertEqual(strp_output[:3], ymd_tuple, msg)
Esempio n. 27
0
 def test_gregorian_calculation(self):
     if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=409557"):
        return
     # Test that Gregorian date can be calculated from Julian day
     format_string = "%Y %H %M %S %w %j %Z"
     result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
                                 format_string)
     self.assertTrue(result.tm_year == self.time_tuple.tm_year and
                      result.tm_mon == self.time_tuple.tm_mon and
                      result.tm_mday == self.time_tuple.tm_mday,
                     "Calculation of Gregorian date failed;"
                      "%s-%s-%s != %s-%s-%s" %
                      (result.tm_year, result.tm_mon, result.tm_mday,
                       self.time_tuple.tm_year, self.time_tuple.tm_mon,
                       self.time_tuple.tm_mday))
Esempio n. 28
0
 def test_time_re_recreation(self):
     # Make sure cache is recreated when current locale does not match what
     # cached object was created with.
     _strptime._strptime_time("10", "%d")
     _strptime._strptime_time("2005", "%Y")
     _strptime._TimeRE_cache.locale_time.lang = "Ni"
     original_time_re = id(_strptime._TimeRE_cache)
     _strptime._strptime_time("10", "%d")
     self.failIfEqual(original_time_re, id(_strptime._TimeRE_cache))
     self.failUnlessEqual(len(_strptime._regex_cache), 1)
Esempio n. 29
0
 def test_time_re_recreation(self):
     # Make sure cache is recreated when current locale does not match what
     # cached object was created with.
     _strptime._strptime_time("10", "%d")
     _strptime._strptime_time("2005", "%Y")
     _strptime._TimeRE_cache.locale_time.lang = "Ni"
     original_time_re = _strptime._TimeRE_cache
     _strptime._strptime_time("10", "%d")
     self.assertIsNot(original_time_re, _strptime._TimeRE_cache)
     self.assertEqual(len(_strptime._regex_cache), 1)
Esempio n. 30
0
    def test_bad_timezone(self):
        # Explicitly test possibility of bad timezone;
        # when time.tzname[0] == time.tzname[1] and time.daylight
        tz_name = time.tzname[0]
        if tz_name.upper() in ("UTC", "GMT"):
            self.skipTest('need non-UTC/GMT timezone')

        with support.swap_attr(time, 'tzname', (tz_name, tz_name)), \
             support.swap_attr(time, 'daylight', 1), \
             support.swap_attr(time, 'tzset', lambda: None):
            time.tzname = (tz_name, tz_name)
            time.daylight = 1
            tz_value = _strptime._strptime_time(tz_name, "%Z")[8]
            self.assertEqual(tz_value, -1,
                    "%s lead to a timezone value of %s instead of -1 when "
                    "time.daylight set to %s and passing in %s" %
                    (time.tzname, tz_value, time.daylight, tz_name))
Esempio n. 31
0
 def test_defaults(self):
     defaults = 1900, 1, 1, 0, 0, 0, 0, 1, -1
     strp_output = _strptime._strptime_time('1', '%m')
     self.assertTrue(strp_output == defaults, 
         'Default values for strptime() are incorrect; %s != %s' % (
         strp_output, defaults))
Esempio n. 32
0
 def test_all_julian_days(self):
     eq = self.assertEqual
     for i in range(1, 367):
         eq(_strptime._strptime_time('%d 2004' % i, '%j %Y')[7], i)
Esempio n. 33
0
 def test_new_localetime(self):
     locale_time_id = _strptime._TimeRE_cache.locale_time
     _strptime._TimeRE_cache.locale_time.lang = 'Ni'
     _strptime._strptime_time('10', '%d')
     self.assertIsNot(locale_time_id, _strptime._TimeRE_cache.locale_time)
Esempio n. 34
0
 def check(value, format, *expected):
     self.assertEqual(
         _strptime._strptime_time(value, format)[:-1], expected)
Esempio n. 35
0
def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
    from _strptime import _strptime_time
    return _strptime_time(data_string, format)
Esempio n. 36
0
 def test_percent(self):
     strf_output = time.strftime('%m %% %Y', self.time_tuple)
     strp_output = _strptime._strptime_time(strf_output, '%m %% %Y')
     self.assertTrue(strp_output[0] == self.time_tuple[0] and 
         strp_output[1] == self.time_tuple[1],
         'handling of percent sign failed')
Esempio n. 37
0
 def test_escaping(self):
     need_escaping = '.^$*+?{}\\[]|)('
     self.assertTrue(_strptime._strptime_time(need_escaping, need_escaping))
Esempio n. 38
0
 def test_strptime_exception_context(self):
     # check that this doesn't chain exceptions needlessly (see #17572)
     with self.assertRaises(ValueError) as e:
         _strptime._strptime_time('', '%D')
     self.assertIs(e.exception.__suppress_context__, True)
Esempio n. 39
0
 def test_all_julian_days(self):
     eq = self.assertEqual
     for i in range(1, 367):
         # use 2004, since it is a leap year, we have 366 days
         eq(_strptime._strptime_time('%d 2004' % i, '%j %Y')[7], i)
Esempio n. 40
0
 def test_twelve_noon_midnight(self):
     eq = self.assertEqual
     eq(time.strptime('12 PM', '%I %p')[3], 12)
     eq(time.strptime('12 AM', '%I %p')[3], 0)
     eq(_strptime._strptime_time('12 PM', '%I %p')[3], 12)
     eq(_strptime._strptime_time('12 AM', '%I %p')[3], 0)