ยปCore Development>Code coverage>Lib/test/test_strptime.py

Python code coverage for Lib/test/test_strptime.py

#countcontent
1n/a"""PyUnit testing against strptime"""
2n/a
3n/aimport unittest
4n/aimport time
5n/aimport locale
6n/aimport re
7n/aimport os
8n/afrom test import support
9n/afrom datetime import date as datetime_date
10n/a
11n/aimport _strptime
12n/a
13n/aclass getlang_Tests(unittest.TestCase):
14n/a """Test _getlang"""
15n/a def test_basic(self):
16n/a self.assertEqual(_strptime._getlang(), locale.getlocale(locale.LC_TIME))
17n/a
18n/aclass LocaleTime_Tests(unittest.TestCase):
19n/a """Tests for _strptime.LocaleTime.
20n/a
21n/a All values are lower-cased when stored in LocaleTime, so make sure to
22n/a compare values after running ``lower`` on them.
23n/a
24n/a """
25n/a
26n/a def setUp(self):
27n/a """Create time tuple based on current time."""
28n/a self.time_tuple = time.localtime()
29n/a self.LT_ins = _strptime.LocaleTime()
30n/a
31n/a def compare_against_time(self, testing, directive, tuple_position,
32n/a error_msg):
33n/a """Helper method that tests testing against directive based on the
34n/a tuple_position of time_tuple. Uses error_msg as error message.
35n/a
36n/a """
37n/a strftime_output = time.strftime(directive, self.time_tuple).lower()
38n/a comparison = testing[self.time_tuple[tuple_position]]
39n/a self.assertIn(strftime_output, testing,
40n/a "%s: not found in tuple" % error_msg)
41n/a self.assertEqual(comparison, strftime_output,
42n/a "%s: position within tuple incorrect; %s != %s" %
43n/a (error_msg, comparison, strftime_output))
44n/a
45n/a def test_weekday(self):
46n/a # Make sure that full and abbreviated weekday names are correct in
47n/a # both string and position with tuple
48n/a self.compare_against_time(self.LT_ins.f_weekday, '%A', 6,
49n/a "Testing of full weekday name failed")
50n/a self.compare_against_time(self.LT_ins.a_weekday, '%a', 6,
51n/a "Testing of abbreviated weekday name failed")
52n/a
53n/a def test_month(self):
54n/a # Test full and abbreviated month names; both string and position
55n/a # within the tuple
56n/a self.compare_against_time(self.LT_ins.f_month, '%B', 1,
57n/a "Testing against full month name failed")
58n/a self.compare_against_time(self.LT_ins.a_month, '%b', 1,
59n/a "Testing against abbreviated month name failed")
60n/a
61n/a def test_am_pm(self):
62n/a # Make sure AM/PM representation done properly
63n/a strftime_output = time.strftime("%p", self.time_tuple).lower()
64n/a self.assertIn(strftime_output, self.LT_ins.am_pm,
65n/a "AM/PM representation not in tuple")
66n/a if self.time_tuple[3] < 12: position = 0
67n/a else: position = 1
68n/a self.assertEqual(self.LT_ins.am_pm[position], strftime_output,
69n/a "AM/PM representation in the wrong position within the tuple")
70n/a
71n/a def test_timezone(self):
72n/a # Make sure timezone is correct
73n/a timezone = time.strftime("%Z", self.time_tuple).lower()
74n/a if timezone:
75n/a self.assertTrue(timezone in self.LT_ins.timezone[0] or
76n/a timezone in self.LT_ins.timezone[1],
77n/a "timezone %s not found in %s" %
78n/a (timezone, self.LT_ins.timezone))
79n/a
80n/a def test_date_time(self):
81n/a # Check that LC_date_time, LC_date, and LC_time are correct
82n/a # the magic date is used so as to not have issues with %c when day of
83n/a # the month is a single digit and has a leading space. This is not an
84n/a # issue since strptime still parses it correctly. The problem is
85n/a # testing these directives for correctness by comparing strftime
86n/a # output.
87n/a magic_date = (1999, 3, 17, 22, 44, 55, 2, 76, 0)
88n/a strftime_output = time.strftime("%c", magic_date)
89n/a self.assertEqual(time.strftime(self.LT_ins.LC_date_time, magic_date),
90n/a strftime_output, "LC_date_time incorrect")
91n/a strftime_output = time.strftime("%x", magic_date)
92n/a self.assertEqual(time.strftime(self.LT_ins.LC_date, magic_date),
93n/a strftime_output, "LC_date incorrect")
94n/a strftime_output = time.strftime("%X", magic_date)
95n/a self.assertEqual(time.strftime(self.LT_ins.LC_time, magic_date),
96n/a strftime_output, "LC_time incorrect")
97n/a LT = _strptime.LocaleTime()
98n/a LT.am_pm = ('', '')
99n/a self.assertTrue(LT.LC_time, "LocaleTime's LC directives cannot handle "
100n/a "empty strings")
101n/a
102n/a def test_lang(self):
103n/a # Make sure lang is set to what _getlang() returns
104n/a # Assuming locale has not changed between now and when self.LT_ins was created
105n/a self.assertEqual(self.LT_ins.lang, _strptime._getlang())
106n/a
107n/a
108n/aclass TimeRETests(unittest.TestCase):
109n/a """Tests for TimeRE."""
110n/a
111n/a def setUp(self):
112n/a """Construct generic TimeRE object."""
113n/a self.time_re = _strptime.TimeRE()
114n/a self.locale_time = _strptime.LocaleTime()
115n/a
116n/a def test_pattern(self):
117n/a # Test TimeRE.pattern
118n/a pattern_string = self.time_re.pattern(r"%a %A %d")
119n/a self.assertTrue(pattern_string.find(self.locale_time.a_weekday[2]) != -1,
120n/a "did not find abbreviated weekday in pattern string '%s'" %
121n/a pattern_string)
122n/a self.assertTrue(pattern_string.find(self.locale_time.f_weekday[4]) != -1,
123n/a "did not find full weekday in pattern string '%s'" %
124n/a pattern_string)
125n/a self.assertTrue(pattern_string.find(self.time_re['d']) != -1,
126n/a "did not find 'd' directive pattern string '%s'" %
127n/a pattern_string)
128n/a
129n/a def test_pattern_escaping(self):
130n/a # Make sure any characters in the format string that might be taken as
131n/a # regex syntax is escaped.
132n/a pattern_string = self.time_re.pattern(r"\d+")
133n/a self.assertIn(r"\\d\+", pattern_string,
134n/a "%s does not have re characters escaped properly" %
135n/a pattern_string)
136n/a
137n/a def test_compile(self):
138n/a # Check that compiled regex is correct
139n/a found = self.time_re.compile(r"%A").match(self.locale_time.f_weekday[6])
140n/a self.assertTrue(found and found.group('A') == self.locale_time.f_weekday[6],
141n/a "re object for '%A' failed")
142n/a compiled = self.time_re.compile(r"%a %b")
143n/a found = compiled.match("%s %s" % (self.locale_time.a_weekday[4],
144n/a self.locale_time.a_month[4]))
145n/a self.assertTrue(found,
146n/a "Match failed with '%s' regex and '%s' string" %
147n/a (compiled.pattern, "%s %s" % (self.locale_time.a_weekday[4],
148n/a self.locale_time.a_month[4])))
149n/a self.assertTrue(found.group('a') == self.locale_time.a_weekday[4] and
150n/a found.group('b') == self.locale_time.a_month[4],
151n/a "re object couldn't find the abbreviated weekday month in "
152n/a "'%s' using '%s'; group 'a' = '%s', group 'b' = %s'" %
153n/a (found.string, found.re.pattern, found.group('a'),
154n/a found.group('b')))
155n/a for directive in ('a','A','b','B','c','d','G','H','I','j','m','M','p',
156n/a 'S','u','U','V','w','W','x','X','y','Y','Z','%'):
157n/a compiled = self.time_re.compile("%" + directive)
158n/a found = compiled.match(time.strftime("%" + directive))
159n/a self.assertTrue(found, "Matching failed on '%s' using '%s' regex" %
160n/a (time.strftime("%" + directive),
161n/a compiled.pattern))
162n/a
163n/a def test_blankpattern(self):
164n/a # Make sure when tuple or something has no values no regex is generated.
165n/a # Fixes bug #661354
166n/a test_locale = _strptime.LocaleTime()
167n/a test_locale.timezone = (frozenset(), frozenset())
168n/a self.assertEqual(_strptime.TimeRE(test_locale).pattern("%Z"), '',
169n/a "with timezone == ('',''), TimeRE().pattern('%Z') != ''")
170n/a
171n/a def test_matching_with_escapes(self):
172n/a # Make sure a format that requires escaping of characters works
173n/a compiled_re = self.time_re.compile(r"\w+ %m")
174n/a found = compiled_re.match(r"\w+ 10")
175n/a self.assertTrue(found, r"Escaping failed of format '\w+ 10'")
176n/a
177n/a def test_locale_data_w_regex_metacharacters(self):
178n/a # Check that if locale data contains regex metacharacters they are
179n/a # escaped properly.
180n/a # Discovered by bug #1039270 .
181n/a locale_time = _strptime.LocaleTime()
182n/a locale_time.timezone = (frozenset(("utc", "gmt",
183n/a "Tokyo (standard time)")),
184n/a frozenset("Tokyo (daylight time)"))
185n/a time_re = _strptime.TimeRE(locale_time)
186n/a self.assertTrue(time_re.compile("%Z").match("Tokyo (standard time)"),
187n/a "locale data that contains regex metacharacters is not"
188n/a " properly escaped")
189n/a
190n/a def test_whitespace_substitution(self):
191n/a # When pattern contains whitespace, make sure it is taken into account
192n/a # so as to not allow subpatterns to end up next to each other and
193n/a # "steal" characters from each other.
194n/a pattern = self.time_re.pattern('%j %H')
195n/a self.assertFalse(re.match(pattern, "180"))
196n/a self.assertTrue(re.match(pattern, "18 0"))
197n/a
198n/a
199n/aclass StrptimeTests(unittest.TestCase):
200n/a """Tests for _strptime.strptime."""
201n/a
202n/a def setUp(self):
203n/a """Create testing time tuple."""
204n/a self.time_tuple = time.gmtime()
205n/a
206n/a def test_ValueError(self):
207n/a # Make sure ValueError is raised when match fails or format is bad
208n/a self.assertRaises(ValueError, _strptime._strptime_time, data_string="%d",
209n/a format="%A")
210n/a for bad_format in ("%", "% ", "%e"):
211n/a try:
212n/a _strptime._strptime_time("2005", bad_format)
213n/a except ValueError:
214n/a continue
215n/a except Exception as err:
216n/a self.fail("'%s' raised %s, not ValueError" %
217n/a (bad_format, err.__class__.__name__))
218n/a else:
219n/a self.fail("'%s' did not raise ValueError" % bad_format)
220n/a
221n/a # Ambiguous or incomplete cases using ISO year/week/weekday directives
222n/a # 1. ISO week (%V) is specified, but the year is specified with %Y
223n/a # instead of %G
224n/a with self.assertRaises(ValueError):
225n/a _strptime._strptime("1999 50", "%Y %V")
226n/a # 2. ISO year (%G) and ISO week (%V) are specified, but weekday is not
227n/a with self.assertRaises(ValueError):
228n/a _strptime._strptime("1999 51", "%G %V")
229n/a # 3. ISO year (%G) and weekday are specified, but ISO week (%V) is not
230n/a for w in ('A', 'a', 'w', 'u'):
231n/a with self.assertRaises(ValueError):
232n/a _strptime._strptime("1999 51","%G %{}".format(w))
233n/a # 4. ISO year is specified alone (e.g. time.strptime('2015', '%G'))
234n/a with self.assertRaises(ValueError):
235n/a _strptime._strptime("2015", "%G")
236n/a # 5. Julian/ordinal day (%j) is specified with %G, but not %Y
237n/a with self.assertRaises(ValueError):
238n/a _strptime._strptime("1999 256", "%G %j")
239n/a
240n/a
241n/a def test_strptime_exception_context(self):
242n/a # check that this doesn't chain exceptions needlessly (see #17572)
243n/a with self.assertRaises(ValueError) as e:
244n/a _strptime._strptime_time('', '%D')
245n/a self.assertIs(e.exception.__suppress_context__, True)
246n/a # additional check for IndexError branch (issue #19545)
247n/a with self.assertRaises(ValueError) as e:
248n/a _strptime._strptime_time('19', '%Y %')
249n/a self.assertIs(e.exception.__suppress_context__, True)
250n/a
251n/a def test_unconverteddata(self):
252n/a # Check ValueError is raised when there is unconverted data
253n/a self.assertRaises(ValueError, _strptime._strptime_time, "10 12", "%m")
254n/a
255n/a def helper(self, directive, position):
256n/a """Helper fxn in testing."""
257n/a strf_output = time.strftime("%" + directive, self.time_tuple)
258n/a strp_output = _strptime._strptime_time(strf_output, "%" + directive)
259n/a self.assertTrue(strp_output[position] == self.time_tuple[position],
260n/a "testing of '%s' directive failed; '%s' -> %s != %s" %
261n/a (directive, strf_output, strp_output[position],
262n/a self.time_tuple[position]))
263n/a
264n/a def test_year(self):
265n/a # Test that the year is handled properly
266n/a for directive in ('y', 'Y'):
267n/a self.helper(directive, 0)
268n/a # Must also make sure %y values are correct for bounds set by Open Group
269n/a for century, bounds in ((1900, ('69', '99')), (2000, ('00', '68'))):
270n/a for bound in bounds:
271n/a strp_output = _strptime._strptime_time(bound, '%y')
272n/a expected_result = century + int(bound)
273n/a self.assertTrue(strp_output[0] == expected_result,
274n/a "'y' test failed; passed in '%s' "
275n/a "and returned '%s'" % (bound, strp_output[0]))
276n/a
277n/a def test_month(self):
278n/a # Test for month directives
279n/a for directive in ('B', 'b', 'm'):
280n/a self.helper(directive, 1)
281n/a
282n/a def test_day(self):
283n/a # Test for day directives
284n/a self.helper('d', 2)
285n/a
286n/a def test_hour(self):
287n/a # Test hour directives
288n/a self.helper('H', 3)
289n/a strf_output = time.strftime("%I %p", self.time_tuple)
290n/a strp_output = _strptime._strptime_time(strf_output, "%I %p")
291n/a self.assertTrue(strp_output[3] == self.time_tuple[3],
292n/a "testing of '%%I %%p' directive failed; '%s' -> %s != %s" %
293n/a (strf_output, strp_output[3], self.time_tuple[3]))
294n/a
295n/a def test_minute(self):
296n/a # Test minute directives
297n/a self.helper('M', 4)
298n/a
299n/a def test_second(self):
300n/a # Test second directives
301n/a self.helper('S', 5)
302n/a
303n/a def test_fraction(self):
304n/a # Test microseconds
305n/a import datetime
306n/a d = datetime.datetime(2012, 12, 20, 12, 34, 56, 78987)
307n/a tup, frac = _strptime._strptime(str(d), format="%Y-%m-%d %H:%M:%S.%f")
308n/a self.assertEqual(frac, d.microsecond)
309n/a
310n/a def test_weekday(self):
311n/a # Test weekday directives
312n/a for directive in ('A', 'a', 'w', 'u'):
313n/a self.helper(directive,6)
314n/a
315n/a def test_julian(self):
316n/a # Test julian directives
317n/a self.helper('j', 7)
318n/a
319n/a def test_timezone(self):
320n/a # Test timezone directives.
321n/a # When gmtime() is used with %Z, entire result of strftime() is empty.
322n/a # Check for equal timezone names deals with bad locale info when this
323n/a # occurs; first found in FreeBSD 4.4.
324n/a strp_output = _strptime._strptime_time("UTC", "%Z")
325n/a self.assertEqual(strp_output.tm_isdst, 0)
326n/a strp_output = _strptime._strptime_time("GMT", "%Z")
327n/a self.assertEqual(strp_output.tm_isdst, 0)
328n/a time_tuple = time.localtime()
329n/a strf_output = time.strftime("%Z") #UTC does not have a timezone
330n/a strp_output = _strptime._strptime_time(strf_output, "%Z")
331n/a locale_time = _strptime.LocaleTime()
332n/a if time.tzname[0] != time.tzname[1] or not time.daylight:
333n/a self.assertTrue(strp_output[8] == time_tuple[8],
334n/a "timezone check failed; '%s' -> %s != %s" %
335n/a (strf_output, strp_output[8], time_tuple[8]))
336n/a else:
337n/a self.assertTrue(strp_output[8] == -1,
338n/a "LocaleTime().timezone has duplicate values and "
339n/a "time.daylight but timezone value not set to -1")
340n/a
341n/a def test_bad_timezone(self):
342n/a # Explicitly test possibility of bad timezone;
343n/a # when time.tzname[0] == time.tzname[1] and time.daylight
344n/a tz_name = time.tzname[0]
345n/a if tz_name.upper() in ("UTC", "GMT"):
346n/a self.skipTest('need non-UTC/GMT timezone')
347n/a
348n/a with support.swap_attr(time, 'tzname', (tz_name, tz_name)), \
349n/a support.swap_attr(time, 'daylight', 1), \
350n/a support.swap_attr(time, 'tzset', lambda: None):
351n/a time.tzname = (tz_name, tz_name)
352n/a time.daylight = 1
353n/a tz_value = _strptime._strptime_time(tz_name, "%Z")[8]
354n/a self.assertEqual(tz_value, -1,
355n/a "%s lead to a timezone value of %s instead of -1 when "
356n/a "time.daylight set to %s and passing in %s" %
357n/a (time.tzname, tz_value, time.daylight, tz_name))
358n/a
359n/a def test_date_time(self):
360n/a # Test %c directive
361n/a for position in range(6):
362n/a self.helper('c', position)
363n/a
364n/a def test_date(self):
365n/a # Test %x directive
366n/a for position in range(0,3):
367n/a self.helper('x', position)
368n/a
369n/a def test_time(self):
370n/a # Test %X directive
371n/a for position in range(3,6):
372n/a self.helper('X', position)
373n/a
374n/a def test_percent(self):
375n/a # Make sure % signs are handled properly
376n/a strf_output = time.strftime("%m %% %Y", self.time_tuple)
377n/a strp_output = _strptime._strptime_time(strf_output, "%m %% %Y")
378n/a self.assertTrue(strp_output[0] == self.time_tuple[0] and
379n/a strp_output[1] == self.time_tuple[1],
380n/a "handling of percent sign failed")
381n/a
382n/a def test_caseinsensitive(self):
383n/a # Should handle names case-insensitively.
384n/a strf_output = time.strftime("%B", self.time_tuple)
385n/a self.assertTrue(_strptime._strptime_time(strf_output.upper(), "%B"),
386n/a "strptime does not handle ALL-CAPS names properly")
387n/a self.assertTrue(_strptime._strptime_time(strf_output.lower(), "%B"),
388n/a "strptime does not handle lowercase names properly")
389n/a self.assertTrue(_strptime._strptime_time(strf_output.capitalize(), "%B"),
390n/a "strptime does not handle capword names properly")
391n/a
392n/a def test_defaults(self):
393n/a # Default return value should be (1900, 1, 1, 0, 0, 0, 0, 1, 0)
394n/a defaults = (1900, 1, 1, 0, 0, 0, 0, 1, -1)
395n/a strp_output = _strptime._strptime_time('1', '%m')
396n/a self.assertTrue(strp_output == defaults,
397n/a "Default values for strptime() are incorrect;"
398n/a " %s != %s" % (strp_output, defaults))
399n/a
400n/a def test_escaping(self):
401n/a # Make sure all characters that have regex significance are escaped.
402n/a # Parentheses are in a purposeful order; will cause an error of
403n/a # unbalanced parentheses when the regex is compiled if they are not
404n/a # escaped.
405n/a # Test instigated by bug #796149 .
406n/a need_escaping = r".^$*+?{}\[]|)("
407n/a self.assertTrue(_strptime._strptime_time(need_escaping, need_escaping))
408n/a
409n/a def test_feb29_on_leap_year_without_year(self):
410n/a time.strptime("Feb 29", "%b %d")
411n/a
412n/a def test_mar1_comes_after_feb29_even_when_omitting_the_year(self):
413n/a self.assertLess(
414n/a time.strptime("Feb 29", "%b %d"),
415n/a time.strptime("Mar 1", "%b %d"))
416n/a
417n/aclass Strptime12AMPMTests(unittest.TestCase):
418n/a """Test a _strptime regression in '%I %p' at 12 noon (12 PM)"""
419n/a
420n/a def test_twelve_noon_midnight(self):
421n/a eq = self.assertEqual
422n/a eq(time.strptime('12 PM', '%I %p')[3], 12)
423n/a eq(time.strptime('12 AM', '%I %p')[3], 0)
424n/a eq(_strptime._strptime_time('12 PM', '%I %p')[3], 12)
425n/a eq(_strptime._strptime_time('12 AM', '%I %p')[3], 0)
426n/a
427n/a
428n/aclass JulianTests(unittest.TestCase):
429n/a """Test a _strptime regression that all julian (1-366) are accepted"""
430n/a
431n/a def test_all_julian_days(self):
432n/a eq = self.assertEqual
433n/a for i in range(1, 367):
434n/a # use 2004, since it is a leap year, we have 366 days
435n/a eq(_strptime._strptime_time('%d 2004' % i, '%j %Y')[7], i)
436n/a
437n/aclass CalculationTests(unittest.TestCase):
438n/a """Test that strptime() fills in missing info correctly"""
439n/a
440n/a def setUp(self):
441n/a self.time_tuple = time.gmtime()
442n/a
443n/a def test_julian_calculation(self):
444n/a # Make sure that when Julian is missing that it is calculated
445n/a format_string = "%Y %m %d %H %M %S %w %Z"
446n/a result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
447n/a format_string)
448n/a self.assertTrue(result.tm_yday == self.time_tuple.tm_yday,
449n/a "Calculation of tm_yday failed; %s != %s" %
450n/a (result.tm_yday, self.time_tuple.tm_yday))
451n/a
452n/a def test_gregorian_calculation(self):
453n/a # Test that Gregorian date can be calculated from Julian day
454n/a format_string = "%Y %H %M %S %w %j %Z"
455n/a result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
456n/a format_string)
457n/a self.assertTrue(result.tm_year == self.time_tuple.tm_year and
458n/a result.tm_mon == self.time_tuple.tm_mon and
459n/a result.tm_mday == self.time_tuple.tm_mday,
460n/a "Calculation of Gregorian date failed;"
461n/a "%s-%s-%s != %s-%s-%s" %
462n/a (result.tm_year, result.tm_mon, result.tm_mday,
463n/a self.time_tuple.tm_year, self.time_tuple.tm_mon,
464n/a self.time_tuple.tm_mday))
465n/a
466n/a def test_day_of_week_calculation(self):
467n/a # Test that the day of the week is calculated as needed
468n/a format_string = "%Y %m %d %H %S %j %Z"
469n/a result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple),
470n/a format_string)
471n/a self.assertTrue(result.tm_wday == self.time_tuple.tm_wday,
472n/a "Calculation of day of the week failed;"
473n/a "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday))
474n/a
475n/a if support.is_android:
476n/a # Issue #26929: strftime() on Android incorrectly formats %V or %G for
477n/a # the last or the first incomplete week in a year.
478n/a _ymd_excluded = ((1905, 1, 1), (1906, 12, 31), (2008, 12, 29),
479n/a (1917, 12, 31))
480n/a _formats_excluded = ('%G %V',)
481n/a else:
482n/a _ymd_excluded = ()
483n/a _formats_excluded = ()
484n/a
485n/a def test_week_of_year_and_day_of_week_calculation(self):
486n/a # Should be able to infer date if given year, week of year (%U or %W)
487n/a # and day of the week
488n/a def test_helper(ymd_tuple, test_reason):
489n/a for year_week_format in ('%Y %W', '%Y %U', '%G %V'):
490n/a if (year_week_format in self._formats_excluded and
491n/a ymd_tuple in self._ymd_excluded):
492n/a return
493n/a for weekday_format in ('%w', '%u', '%a', '%A'):
494n/a format_string = year_week_format + ' ' + weekday_format
495n/a with self.subTest(test_reason,
496n/a date=ymd_tuple,
497n/a format=format_string):
498n/a dt_date = datetime_date(*ymd_tuple)
499n/a strp_input = dt_date.strftime(format_string)
500n/a strp_output = _strptime._strptime_time(strp_input,
501n/a format_string)
502n/a msg = "%r: %s != %s" % (strp_input,
503n/a strp_output[7],
504n/a dt_date.timetuple()[7])
505n/a self.assertEqual(strp_output[:3], ymd_tuple, msg)
506n/a test_helper((1901, 1, 3), "week 0")
507n/a test_helper((1901, 1, 8), "common case")
508n/a test_helper((1901, 1, 13), "day on Sunday")
509n/a test_helper((1901, 1, 14), "day on Monday")
510n/a test_helper((1905, 1, 1), "Jan 1 on Sunday")
511n/a test_helper((1906, 1, 1), "Jan 1 on Monday")
512n/a test_helper((1906, 1, 7), "first Sunday in a year starting on Monday")
513n/a test_helper((1905, 12, 31), "Dec 31 on Sunday")
514n/a test_helper((1906, 12, 31), "Dec 31 on Monday")
515n/a test_helper((2008, 12, 29), "Monday in the last week of the year")
516n/a test_helper((2008, 12, 22), "Monday in the second-to-last week of the "
517n/a "year")
518n/a test_helper((1978, 10, 23), "randomly chosen date")
519n/a test_helper((2004, 12, 18), "randomly chosen date")
520n/a test_helper((1978, 10, 23), "year starting and ending on Monday while "
521n/a "date not on Sunday or Monday")
522n/a test_helper((1917, 12, 17), "year starting and ending on Monday with "
523n/a "a Monday not at the beginning or end "
524n/a "of the year")
525n/a test_helper((1917, 12, 31), "Dec 31 on Monday with year starting and "
526n/a "ending on Monday")
527n/a test_helper((2007, 1, 7), "First Sunday of 2007")
528n/a test_helper((2007, 1, 14), "Second Sunday of 2007")
529n/a test_helper((2006, 12, 31), "Last Sunday of 2006")
530n/a test_helper((2006, 12, 24), "Second to last Sunday of 2006")
531n/a
532n/a def test_week_0(self):
533n/a def check(value, format, *expected):
534n/a self.assertEqual(_strptime._strptime_time(value, format)[:-1], expected)
535n/a check('2015 0 0', '%Y %U %w', 2014, 12, 28, 0, 0, 0, 6, 362)
536n/a check('2015 0 0', '%Y %W %w', 2015, 1, 4, 0, 0, 0, 6, 4)
537n/a check('2015 1 1', '%G %V %u', 2014, 12, 29, 0, 0, 0, 0, 363)
538n/a check('2015 0 1', '%Y %U %w', 2014, 12, 29, 0, 0, 0, 0, 363)
539n/a check('2015 0 1', '%Y %W %w', 2014, 12, 29, 0, 0, 0, 0, 363)
540n/a check('2015 1 2', '%G %V %u', 2014, 12, 30, 0, 0, 0, 1, 364)
541n/a check('2015 0 2', '%Y %U %w', 2014, 12, 30, 0, 0, 0, 1, 364)
542n/a check('2015 0 2', '%Y %W %w', 2014, 12, 30, 0, 0, 0, 1, 364)
543n/a check('2015 1 3', '%G %V %u', 2014, 12, 31, 0, 0, 0, 2, 365)
544n/a check('2015 0 3', '%Y %U %w', 2014, 12, 31, 0, 0, 0, 2, 365)
545n/a check('2015 0 3', '%Y %W %w', 2014, 12, 31, 0, 0, 0, 2, 365)
546n/a check('2015 1 4', '%G %V %u', 2015, 1, 1, 0, 0, 0, 3, 1)
547n/a check('2015 0 4', '%Y %U %w', 2015, 1, 1, 0, 0, 0, 3, 1)
548n/a check('2015 0 4', '%Y %W %w', 2015, 1, 1, 0, 0, 0, 3, 1)
549n/a check('2015 1 5', '%G %V %u', 2015, 1, 2, 0, 0, 0, 4, 2)
550n/a check('2015 0 5', '%Y %U %w', 2015, 1, 2, 0, 0, 0, 4, 2)
551n/a check('2015 0 5', '%Y %W %w', 2015, 1, 2, 0, 0, 0, 4, 2)
552n/a check('2015 1 6', '%G %V %u', 2015, 1, 3, 0, 0, 0, 5, 3)
553n/a check('2015 0 6', '%Y %U %w', 2015, 1, 3, 0, 0, 0, 5, 3)
554n/a check('2015 0 6', '%Y %W %w', 2015, 1, 3, 0, 0, 0, 5, 3)
555n/a check('2015 1 7', '%G %V %u', 2015, 1, 4, 0, 0, 0, 6, 4)
556n/a
557n/a check('2009 0 0', '%Y %U %w', 2008, 12, 28, 0, 0, 0, 6, 363)
558n/a check('2009 0 0', '%Y %W %w', 2009, 1, 4, 0, 0, 0, 6, 4)
559n/a check('2009 1 1', '%G %V %u', 2008, 12, 29, 0, 0, 0, 0, 364)
560n/a check('2009 0 1', '%Y %U %w', 2008, 12, 29, 0, 0, 0, 0, 364)
561n/a check('2009 0 1', '%Y %W %w', 2008, 12, 29, 0, 0, 0, 0, 364)
562n/a check('2009 1 2', '%G %V %u', 2008, 12, 30, 0, 0, 0, 1, 365)
563n/a check('2009 0 2', '%Y %U %w', 2008, 12, 30, 0, 0, 0, 1, 365)
564n/a check('2009 0 2', '%Y %W %w', 2008, 12, 30, 0, 0, 0, 1, 365)
565n/a check('2009 1 3', '%G %V %u', 2008, 12, 31, 0, 0, 0, 2, 366)
566n/a check('2009 0 3', '%Y %U %w', 2008, 12, 31, 0, 0, 0, 2, 366)
567n/a check('2009 0 3', '%Y %W %w', 2008, 12, 31, 0, 0, 0, 2, 366)
568n/a check('2009 1 4', '%G %V %u', 2009, 1, 1, 0, 0, 0, 3, 1)
569n/a check('2009 0 4', '%Y %U %w', 2009, 1, 1, 0, 0, 0, 3, 1)
570n/a check('2009 0 4', '%Y %W %w', 2009, 1, 1, 0, 0, 0, 3, 1)
571n/a check('2009 1 5', '%G %V %u', 2009, 1, 2, 0, 0, 0, 4, 2)
572n/a check('2009 0 5', '%Y %U %w', 2009, 1, 2, 0, 0, 0, 4, 2)
573n/a check('2009 0 5', '%Y %W %w', 2009, 1, 2, 0, 0, 0, 4, 2)
574n/a check('2009 1 6', '%G %V %u', 2009, 1, 3, 0, 0, 0, 5, 3)
575n/a check('2009 0 6', '%Y %U %w', 2009, 1, 3, 0, 0, 0, 5, 3)
576n/a check('2009 0 6', '%Y %W %w', 2009, 1, 3, 0, 0, 0, 5, 3)
577n/a check('2009 1 7', '%G %V %u', 2009, 1, 4, 0, 0, 0, 6, 4)
578n/a
579n/a
580n/aclass CacheTests(unittest.TestCase):
581n/a """Test that caching works properly."""
582n/a
583n/a def test_time_re_recreation(self):
584n/a # Make sure cache is recreated when current locale does not match what
585n/a # cached object was created with.
586n/a _strptime._strptime_time("10", "%d")
587n/a _strptime._strptime_time("2005", "%Y")
588n/a _strptime._TimeRE_cache.locale_time.lang = "Ni"
589n/a original_time_re = _strptime._TimeRE_cache
590n/a _strptime._strptime_time("10", "%d")
591n/a self.assertIsNot(original_time_re, _strptime._TimeRE_cache)
592n/a self.assertEqual(len(_strptime._regex_cache), 1)
593n/a
594n/a def test_regex_cleanup(self):
595n/a # Make sure cached regexes are discarded when cache becomes "full".
596n/a try:
597n/a del _strptime._regex_cache['%d']
598n/a except KeyError:
599n/a pass
600n/a bogus_key = 0
601n/a while len(_strptime._regex_cache) <= _strptime._CACHE_MAX_SIZE:
602n/a _strptime._regex_cache[bogus_key] = None
603n/a bogus_key += 1
604n/a _strptime._strptime_time("10", "%d")
605n/a self.assertEqual(len(_strptime._regex_cache), 1)
606n/a
607n/a def test_new_localetime(self):
608n/a # A new LocaleTime instance should be created when a new TimeRE object
609n/a # is created.
610n/a locale_time_id = _strptime._TimeRE_cache.locale_time
611n/a _strptime._TimeRE_cache.locale_time.lang = "Ni"
612n/a _strptime._strptime_time("10", "%d")
613n/a self.assertIsNot(locale_time_id, _strptime._TimeRE_cache.locale_time)
614n/a
615n/a def test_TimeRE_recreation_locale(self):
616n/a # The TimeRE instance should be recreated upon changing the locale.
617n/a locale_info = locale.getlocale(locale.LC_TIME)
618n/a try:
619n/a locale.setlocale(locale.LC_TIME, ('en_US', 'UTF8'))
620n/a except locale.Error:
621n/a self.skipTest('test needs en_US.UTF8 locale')
622n/a try:
623n/a _strptime._strptime_time('10', '%d')
624n/a # Get id of current cache object.
625n/a first_time_re = _strptime._TimeRE_cache
626n/a try:
627n/a # Change the locale and force a recreation of the cache.
628n/a locale.setlocale(locale.LC_TIME, ('de_DE', 'UTF8'))
629n/a _strptime._strptime_time('10', '%d')
630n/a # Get the new cache object's id.
631n/a second_time_re = _strptime._TimeRE_cache
632n/a # They should not be equal.
633n/a self.assertIsNot(first_time_re, second_time_re)
634n/a # Possible test locale is not supported while initial locale is.
635n/a # If this is the case just suppress the exception and fall-through
636n/a # to the resetting to the original locale.
637n/a except locale.Error:
638n/a self.skipTest('test needs de_DE.UTF8 locale')
639n/a # Make sure we don't trample on the locale setting once we leave the
640n/a # test.
641n/a finally:
642n/a locale.setlocale(locale.LC_TIME, locale_info)
643n/a
644n/a @support.run_with_tz('STD-1DST')
645n/a def test_TimeRE_recreation_timezone(self):
646n/a # The TimeRE instance should be recreated upon changing the timezone.
647n/a oldtzname = time.tzname
648n/a tm = _strptime._strptime_time(time.tzname[0], '%Z')
649n/a self.assertEqual(tm.tm_isdst, 0)
650n/a tm = _strptime._strptime_time(time.tzname[1], '%Z')
651n/a self.assertEqual(tm.tm_isdst, 1)
652n/a # Get id of current cache object.
653n/a first_time_re = _strptime._TimeRE_cache
654n/a # Change the timezone and force a recreation of the cache.
655n/a os.environ['TZ'] = 'EST+05EDT,M3.2.0,M11.1.0'
656n/a time.tzset()
657n/a tm = _strptime._strptime_time(time.tzname[0], '%Z')
658n/a self.assertEqual(tm.tm_isdst, 0)
659n/a tm = _strptime._strptime_time(time.tzname[1], '%Z')
660n/a self.assertEqual(tm.tm_isdst, 1)
661n/a # Get the new cache object's id.
662n/a second_time_re = _strptime._TimeRE_cache
663n/a # They should not be equal.
664n/a self.assertIsNot(first_time_re, second_time_re)
665n/a # Make sure old names no longer accepted.
666n/a with self.assertRaises(ValueError):
667n/a _strptime._strptime_time(oldtzname[0], '%Z')
668n/a with self.assertRaises(ValueError):
669n/a _strptime._strptime_time(oldtzname[1], '%Z')
670n/a
671n/a
672n/aif __name__ == '__main__':
673n/a unittest.main()