Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | """PyUnit testing against strptime""" |
2 | ||
3 | import unittest | |
4 | import time | |
5 | import locale | |
6 | import re | |
7 | import sys | |
8 | from test import test_support | |
9 | from datetime import date as datetime_date | |
10 | ||
11 | import _strptime | |
12 | ||
13 | class getlang_Tests(unittest.TestCase): | |
14 | """Test _getlang""" | |
15 | def test_basic(self): | |
16 | self.failUnlessEqual(_strptime._getlang(), locale.getlocale(locale.LC_TIME)) | |
17 | ||
18 | class LocaleTime_Tests(unittest.TestCase): | |
19 | """Tests for _strptime.LocaleTime. | |
20 | ||
21 | All values are lower-cased when stored in LocaleTime, so make sure to | |
22 | compare values after running ``lower`` on them. | |
23 | ||
24 | """ | |
25 | ||
26 | def setUp(self): | |
27 | """Create time tuple based on current time.""" | |
28 | self.time_tuple = time.localtime() | |
29 | self.LT_ins = _strptime.LocaleTime() | |
30 | ||
31 | def compare_against_time(self, testing, directive, tuple_position, | |
32 | error_msg): | |
33 | """Helper method that tests testing against directive based on the | |
34 | tuple_position of time_tuple. Uses error_msg as error message. | |
35 | ||
36 | """ | |
37 | strftime_output = time.strftime(directive, self.time_tuple).lower() | |
38 | comparison = testing[self.time_tuple[tuple_position]] | |
39 | self.failUnless(strftime_output in testing, "%s: not found in tuple" % | |
40 | error_msg) | |
41 | self.failUnless(comparison == strftime_output, | |
42 | "%s: position within tuple incorrect; %s != %s" % | |
43 | (error_msg, comparison, strftime_output)) | |
44 | ||
45 | def test_weekday(self): | |
46 | # Make sure that full and abbreviated weekday names are correct in | |
47 | # both string and position with tuple | |
48 | self.compare_against_time(self.LT_ins.f_weekday, '%A', 6, | |
49 | "Testing of full weekday name failed") | |
50 | self.compare_against_time(self.LT_ins.a_weekday, '%a', 6, | |
51 | "Testing of abbreviated weekday name failed") | |
52 | ||
53 | def test_month(self): | |
54 | # Test full and abbreviated month names; both string and position | |
55 | # within the tuple | |
56 | self.compare_against_time(self.LT_ins.f_month, '%B', 1, | |
57 | "Testing against full month name failed") | |
58 | self.compare_against_time(self.LT_ins.a_month, '%b', 1, | |
59 | "Testing against abbreviated month name failed") | |
60 | ||
61 | def test_am_pm(self): | |
62 | # Make sure AM/PM representation done properly | |
63 | strftime_output = time.strftime("%p", self.time_tuple).lower() | |
64 | self.failUnless(strftime_output in self.LT_ins.am_pm, | |
65 | "AM/PM representation not in tuple") | |
66 | if self.time_tuple[3] < 12: position = 0 | |
67 | else: position = 1 | |
68 | self.failUnless(strftime_output == self.LT_ins.am_pm[position], | |
69 | "AM/PM representation in the wrong position within the tuple") | |
70 | ||
71 | def test_timezone(self): | |
72 | # Make sure timezone is correct | |
73 | timezone = time.strftime("%Z", self.time_tuple).lower() | |
74 | if timezone: | |
75 | self.failUnless(timezone in self.LT_ins.timezone[0] or \ | |
76 | timezone in self.LT_ins.timezone[1], | |
77 | "timezone %s not found in %s" % | |
78 | (timezone, self.LT_ins.timezone)) | |
79 | ||
80 | def test_date_time(self): | |
81 | # Check that LC_date_time, LC_date, and LC_time are correct | |
82 | # the magic date is used so as to not have issues with %c when day of | |
83 | # the month is a single digit and has a leading space. This is not an | |
84 | # issue since strptime still parses it correctly. The problem is | |
85 | # testing these directives for correctness by comparing strftime | |
86 | # output. | |
87 | magic_date = (1999, 3, 17, 22, 44, 55, 2, 76, 0) | |
88 | strftime_output = time.strftime("%c", magic_date) | |
89 | self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_date_time, | |
90 | magic_date), | |
91 | "LC_date_time incorrect") | |
92 | strftime_output = time.strftime("%x", magic_date) | |
93 | self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_date, | |
94 | magic_date), | |
95 | "LC_date incorrect") | |
96 | strftime_output = time.strftime("%X", magic_date) | |
97 | self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_time, | |
98 | magic_date), | |
99 | "LC_time incorrect") | |
100 | LT = _strptime.LocaleTime() | |
101 | LT.am_pm = ('', '') | |
102 | self.failUnless(LT.LC_time, "LocaleTime's LC directives cannot handle " | |
103 | "empty strings") | |
104 | ||
105 | def test_lang(self): | |
106 | # Make sure lang is set to what _getlang() returns | |
107 | # Assuming locale has not changed between now and when self.LT_ins was created | |
108 | self.failUnlessEqual(self.LT_ins.lang, _strptime._getlang()) | |
109 | ||
110 | ||
111 | class TimeRETests(unittest.TestCase): | |
112 | """Tests for TimeRE.""" | |
113 | ||
114 | def setUp(self): | |
115 | """Construct generic TimeRE object.""" | |
116 | self.time_re = _strptime.TimeRE() | |
117 | self.locale_time = _strptime.LocaleTime() | |
118 | ||
119 | def test_pattern(self): | |
120 | # Test TimeRE.pattern | |
121 | pattern_string = self.time_re.pattern(r"%a %A %d") | |
122 | self.failUnless(pattern_string.find(self.locale_time.a_weekday[2]) != -1, | |
123 | "did not find abbreviated weekday in pattern string '%s'" % | |
124 | pattern_string) | |
125 | self.failUnless(pattern_string.find(self.locale_time.f_weekday[4]) != -1, | |
126 | "did not find full weekday in pattern string '%s'" % | |
127 | pattern_string) | |
128 | self.failUnless(pattern_string.find(self.time_re['d']) != -1, | |
129 | "did not find 'd' directive pattern string '%s'" % | |
130 | pattern_string) | |
131 | ||
132 | def test_pattern_escaping(self): | |
133 | # Make sure any characters in the format string that might be taken as | |
134 | # regex syntax is escaped. | |
135 | pattern_string = self.time_re.pattern("\d+") | |
136 | self.failUnless(r"\\d\+" in pattern_string, | |
137 | "%s does not have re characters escaped properly" % | |
138 | pattern_string) | |
139 | ||
140 | def test_compile(self): | |
141 | # Check that compiled regex is correct | |
142 | found = self.time_re.compile(r"%A").match(self.locale_time.f_weekday[6]) | |
143 | self.failUnless(found and found.group('A') == self.locale_time.f_weekday[6], | |
144 | "re object for '%A' failed") | |
145 | compiled = self.time_re.compile(r"%a %b") | |
146 | found = compiled.match("%s %s" % (self.locale_time.a_weekday[4], | |
147 | self.locale_time.a_month[4])) | |
148 | self.failUnless(found, | |
149 | "Match failed with '%s' regex and '%s' string" % | |
150 | (compiled.pattern, "%s %s" % (self.locale_time.a_weekday[4], | |
151 | self.locale_time.a_month[4]))) | |
152 | self.failUnless(found.group('a') == self.locale_time.a_weekday[4] and | |
153 | found.group('b') == self.locale_time.a_month[4], | |
154 | "re object couldn't find the abbreviated weekday month in " | |
155 | "'%s' using '%s'; group 'a' = '%s', group 'b' = %s'" % | |
156 | (found.string, found.re.pattern, found.group('a'), | |
157 | found.group('b'))) | |
158 | for directive in ('a','A','b','B','c','d','H','I','j','m','M','p','S', | |
159 | 'U','w','W','x','X','y','Y','Z','%'): | |
160 | compiled = self.time_re.compile("%" + directive) | |
161 | found = compiled.match(time.strftime("%" + directive)) | |
162 | self.failUnless(found, "Matching failed on '%s' using '%s' regex" % | |
163 | (time.strftime("%" + directive), | |
164 | compiled.pattern)) | |
165 | ||
166 | def test_blankpattern(self): | |
167 | # Make sure when tuple or something has no values no regex is generated. | |
168 | # Fixes bug #661354 | |
169 | test_locale = _strptime.LocaleTime() | |
170 | test_locale.timezone = (frozenset(), frozenset()) | |
171 | self.failUnless(_strptime.TimeRE(test_locale).pattern("%Z") == '', | |
172 | "with timezone == ('',''), TimeRE().pattern('%Z') != ''") | |
173 | ||
174 | def test_matching_with_escapes(self): | |
175 | # Make sure a format that requires escaping of characters works | |
176 | compiled_re = self.time_re.compile("\w+ %m") | |
177 | found = compiled_re.match("\w+ 10") | |
178 | self.failUnless(found, "Escaping failed of format '\w+ 10'") | |
179 | ||
180 | def test_locale_data_w_regex_metacharacters(self): | |
181 | # Check that if locale data contains regex metacharacters they are | |
182 | # escaped properly. | |
183 | # Discovered by bug #1039270 . | |
184 | locale_time = _strptime.LocaleTime() | |
185 | locale_time.timezone = (frozenset(("utc", "gmt", | |
186 | "Tokyo (standard time)")), | |
187 | frozenset("Tokyo (daylight time)")) | |
188 | time_re = _strptime.TimeRE(locale_time) | |
189 | self.failUnless(time_re.compile("%Z").match("Tokyo (standard time)"), | |
190 | "locale data that contains regex metacharacters is not" | |
191 | " properly escaped") | |
192 | ||
193 | class StrptimeTests(unittest.TestCase): | |
194 | """Tests for _strptime.strptime.""" | |
195 | ||
196 | def setUp(self): | |
197 | """Create testing time tuple.""" | |
198 | self.time_tuple = time.gmtime() | |
199 | ||
200 | def test_TypeError(self): | |
201 | # Make sure ValueError is raised when match fails | |
202 | self.assertRaises(ValueError, _strptime.strptime, data_string="%d", | |
203 | format="%A") | |
204 | ||
205 | def test_unconverteddata(self): | |
206 | # Check ValueError is raised when there is unconverted data | |
207 | self.assertRaises(ValueError, _strptime.strptime, "10 12", "%m") | |
208 | ||
209 | def helper(self, directive, position): | |
210 | """Helper fxn in testing.""" | |
211 | strf_output = time.strftime("%" + directive, self.time_tuple) | |
212 | strp_output = _strptime.strptime(strf_output, "%" + directive) | |
213 | self.failUnless(strp_output[position] == self.time_tuple[position], | |
214 | "testing of '%s' directive failed; '%s' -> %s != %s" % | |
215 | (directive, strf_output, strp_output[position], | |
216 | self.time_tuple[position])) | |
217 | ||
218 | def test_year(self): | |
219 | # Test that the year is handled properly | |
220 | for directive in ('y', 'Y'): | |
221 | self.helper(directive, 0) | |
222 | # Must also make sure %y values are correct for bounds set by Open Group | |
223 | for century, bounds in ((1900, ('69', '99')), (2000, ('00', '68'))): | |
224 | for bound in bounds: | |
225 | strp_output = _strptime.strptime(bound, '%y') | |
226 | expected_result = century + int(bound) | |
227 | self.failUnless(strp_output[0] == expected_result, | |
228 | "'y' test failed; passed in '%s' " | |
229 | "and returned '%s'" % (bound, strp_output[0])) | |
230 | ||
231 | def test_month(self): | |
232 | # Test for month directives | |
233 | for directive in ('B', 'b', 'm'): | |
234 | self.helper(directive, 1) | |
235 | ||
236 | def test_day(self): | |
237 | # Test for day directives | |
238 | self.helper('d', 2) | |
239 | ||
240 | def test_hour(self): | |
241 | # Test hour directives | |
242 | self.helper('H', 3) | |
243 | strf_output = time.strftime("%I %p", self.time_tuple) | |
244 | strp_output = _strptime.strptime(strf_output, "%I %p") | |
245 | self.failUnless(strp_output[3] == self.time_tuple[3], | |
246 | "testing of '%%I %%p' directive failed; '%s' -> %s != %s" % | |
247 | (strf_output, strp_output[3], self.time_tuple[3])) | |
248 | ||
249 | def test_minute(self): | |
250 | # Test minute directives | |
251 | self.helper('M', 4) | |
252 | ||
253 | def test_second(self): | |
254 | # Test second directives | |
255 | self.helper('S', 5) | |
256 | ||
257 | def test_weekday(self): | |
258 | # Test weekday directives | |
259 | for directive in ('A', 'a', 'w'): | |
260 | self.helper(directive,6) | |
261 | ||
262 | def test_julian(self): | |
263 | # Test julian directives | |
264 | self.helper('j', 7) | |
265 | ||
266 | def test_timezone(self): | |
267 | # Test timezone directives. | |
268 | # When gmtime() is used with %Z, entire result of strftime() is empty. | |
269 | # Check for equal timezone names deals with bad locale info when this | |
270 | # occurs; first found in FreeBSD 4.4. | |
271 | strp_output = _strptime.strptime("UTC", "%Z") | |
272 | self.failUnlessEqual(strp_output.tm_isdst, 0) | |
273 | strp_output = _strptime.strptime("GMT", "%Z") | |
274 | self.failUnlessEqual(strp_output.tm_isdst, 0) | |
275 | if sys.platform == "mac": | |
276 | # Timezones don't really work on MacOS9 | |
277 | return | |
278 | time_tuple = time.localtime() | |
279 | strf_output = time.strftime("%Z") #UTC does not have a timezone | |
280 | strp_output = _strptime.strptime(strf_output, "%Z") | |
281 | locale_time = _strptime.LocaleTime() | |
282 | if time.tzname[0] != time.tzname[1] or not time.daylight: | |
283 | self.failUnless(strp_output[8] == time_tuple[8], | |
284 | "timezone check failed; '%s' -> %s != %s" % | |
285 | (strf_output, strp_output[8], time_tuple[8])) | |
286 | else: | |
287 | self.failUnless(strp_output[8] == -1, | |
288 | "LocaleTime().timezone has duplicate values and " | |
289 | "time.daylight but timezone value not set to -1") | |
290 | ||
291 | def test_bad_timezone(self): | |
292 | # Explicitly test possibility of bad timezone; | |
293 | # when time.tzname[0] == time.tzname[1] and time.daylight | |
294 | if sys.platform == "mac": | |
295 | return #MacOS9 has severely broken timezone support. | |
296 | tz_name = time.tzname[0] | |
297 | if tz_name.upper() in ("UTC", "GMT"): | |
298 | return | |
299 | try: | |
300 | original_tzname = time.tzname | |
301 | original_daylight = time.daylight | |
302 | time.tzname = (tz_name, tz_name) | |
303 | time.daylight = 1 | |
304 | tz_value = _strptime.strptime(tz_name, "%Z")[8] | |
305 | self.failUnlessEqual(tz_value, -1, | |
306 | "%s lead to a timezone value of %s instead of -1 when " | |
307 | "time.daylight set to %s and passing in %s" % | |
308 | (time.tzname, tz_value, time.daylight, tz_name)) | |
309 | finally: | |
310 | time.tzname = original_tzname | |
311 | time.daylight = original_daylight | |
312 | ||
313 | def test_date_time(self): | |
314 | # Test %c directive | |
315 | for position in range(6): | |
316 | self.helper('c', position) | |
317 | ||
318 | def test_date(self): | |
319 | # Test %x directive | |
320 | for position in range(0,3): | |
321 | self.helper('x', position) | |
322 | ||
323 | def test_time(self): | |
324 | # Test %X directive | |
325 | for position in range(3,6): | |
326 | self.helper('X', position) | |
327 | ||
328 | def test_percent(self): | |
329 | # Make sure % signs are handled properly | |
330 | strf_output = time.strftime("%m %% %Y", self.time_tuple) | |
331 | strp_output = _strptime.strptime(strf_output, "%m %% %Y") | |
332 | self.failUnless(strp_output[0] == self.time_tuple[0] and | |
333 | strp_output[1] == self.time_tuple[1], | |
334 | "handling of percent sign failed") | |
335 | ||
336 | def test_caseinsensitive(self): | |
337 | # Should handle names case-insensitively. | |
338 | strf_output = time.strftime("%B", self.time_tuple) | |
339 | self.failUnless(_strptime.strptime(strf_output.upper(), "%B"), | |
340 | "strptime does not handle ALL-CAPS names properly") | |
341 | self.failUnless(_strptime.strptime(strf_output.lower(), "%B"), | |
342 | "strptime does not handle lowercase names properly") | |
343 | self.failUnless(_strptime.strptime(strf_output.capitalize(), "%B"), | |
344 | "strptime does not handle capword names properly") | |
345 | ||
346 | def test_defaults(self): | |
347 | # Default return value should be (1900, 1, 1, 0, 0, 0, 0, 1, 0) | |
348 | defaults = (1900, 1, 1, 0, 0, 0, 0, 1, -1) | |
349 | strp_output = _strptime.strptime('1', '%m') | |
350 | self.failUnless(strp_output == defaults, | |
351 | "Default values for strptime() are incorrect;" | |
352 | " %s != %s" % (strp_output, defaults)) | |
353 | ||
354 | def test_escaping(self): | |
355 | # Make sure all characters that have regex significance are escaped. | |
356 | # Parentheses are in a purposeful order; will cause an error of | |
357 | # unbalanced parentheses when the regex is compiled if they are not | |
358 | # escaped. | |
359 | # Test instigated by bug #796149 . | |
360 | need_escaping = ".^$*+?{}\[]|)(" | |
361 | self.failUnless(_strptime.strptime(need_escaping, need_escaping)) | |
362 | ||
363 | class Strptime12AMPMTests(unittest.TestCase): | |
364 | """Test a _strptime regression in '%I %p' at 12 noon (12 PM)""" | |
365 | ||
366 | def test_twelve_noon_midnight(self): | |
367 | eq = self.assertEqual | |
368 | eq(time.strptime('12 PM', '%I %p')[3], 12) | |
369 | eq(time.strptime('12 AM', '%I %p')[3], 0) | |
370 | eq(_strptime.strptime('12 PM', '%I %p')[3], 12) | |
371 | eq(_strptime.strptime('12 AM', '%I %p')[3], 0) | |
372 | ||
373 | ||
374 | class JulianTests(unittest.TestCase): | |
375 | """Test a _strptime regression that all julian (1-366) are accepted""" | |
376 | ||
377 | def test_all_julian_days(self): | |
378 | eq = self.assertEqual | |
379 | for i in range(1, 367): | |
380 | # use 2004, since it is a leap year, we have 366 days | |
381 | eq(_strptime.strptime('%d 2004' % i, '%j %Y')[7], i) | |
382 | ||
383 | class CalculationTests(unittest.TestCase): | |
384 | """Test that strptime() fills in missing info correctly""" | |
385 | ||
386 | def setUp(self): | |
387 | self.time_tuple = time.gmtime() | |
388 | ||
389 | def test_julian_calculation(self): | |
390 | # Make sure that when Julian is missing that it is calculated | |
391 | format_string = "%Y %m %d %H %M %S %w %Z" | |
392 | result = _strptime.strptime(time.strftime(format_string, self.time_tuple), | |
393 | format_string) | |
394 | self.failUnless(result.tm_yday == self.time_tuple.tm_yday, | |
395 | "Calculation of tm_yday failed; %s != %s" % | |
396 | (result.tm_yday, self.time_tuple.tm_yday)) | |
397 | ||
398 | def test_gregorian_calculation(self): | |
399 | # Test that Gregorian date can be calculated from Julian day | |
400 | format_string = "%Y %H %M %S %w %j %Z" | |
401 | result = _strptime.strptime(time.strftime(format_string, self.time_tuple), | |
402 | format_string) | |
403 | self.failUnless(result.tm_year == self.time_tuple.tm_year and | |
404 | result.tm_mon == self.time_tuple.tm_mon and | |
405 | result.tm_mday == self.time_tuple.tm_mday, | |
406 | "Calculation of Gregorian date failed;" | |
407 | "%s-%s-%s != %s-%s-%s" % | |
408 | (result.tm_year, result.tm_mon, result.tm_mday, | |
409 | self.time_tuple.tm_year, self.time_tuple.tm_mon, | |
410 | self.time_tuple.tm_mday)) | |
411 | ||
412 | def test_day_of_week_calculation(self): | |
413 | # Test that the day of the week is calculated as needed | |
414 | format_string = "%Y %m %d %H %S %j %Z" | |
415 | result = _strptime.strptime(time.strftime(format_string, self.time_tuple), | |
416 | format_string) | |
417 | self.failUnless(result.tm_wday == self.time_tuple.tm_wday, | |
418 | "Calculation of day of the week failed;" | |
419 | "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday)) | |
420 | ||
421 | def test_week_of_year_and_day_of_week_calculation(self): | |
422 | # Should be able to infer date if given year, week of year (%U or %W) | |
423 | # and day of the week | |
424 | def test_helper(ymd_tuple, test_reason): | |
425 | for directive in ('W', 'U'): | |
426 | format_string = "%%Y %%%s %%w" % directive | |
427 | dt_date = datetime_date(*ymd_tuple) | |
428 | strp_input = dt_date.strftime(format_string) | |
429 | strp_output = _strptime.strptime(strp_input, format_string) | |
430 | self.failUnless(strp_output[:3] == ymd_tuple, | |
431 | "%s(%s) test failed w/ '%s': %s != %s (%s != %s)" % | |
432 | (test_reason, directive, strp_input, | |
433 | strp_output[:3], ymd_tuple, | |
434 | strp_output[7], dt_date.timetuple()[7])) | |
435 | test_helper((1901, 1, 3), "week 0") | |
436 | test_helper((1901, 1, 8), "common case") | |
437 | test_helper((1901, 1, 13), "day on Sunday") | |
438 | test_helper((1901, 1, 14), "day on Monday") | |
439 | test_helper((1905, 1, 1), "Jan 1 on Sunday") | |
440 | test_helper((1906, 1, 1), "Jan 1 on Monday") | |
441 | test_helper((1906, 1, 7), "first Sunday in a year starting on Monday") | |
442 | test_helper((1905, 12, 31), "Dec 31 on Sunday") | |
443 | test_helper((1906, 12, 31), "Dec 31 on Monday") | |
444 | test_helper((2008, 12, 29), "Monday in the last week of the year") | |
445 | test_helper((2008, 12, 22), "Monday in the second-to-last week of the " | |
446 | "year") | |
447 | test_helper((1978, 10, 23), "randomly chosen date") | |
448 | test_helper((2004, 12, 18), "randomly chosen date") | |
449 | test_helper((1978, 10, 23), "year starting and ending on Monday while " | |
450 | "date not on Sunday or Monday") | |
451 | test_helper((1917, 12, 17), "year starting and ending on Monday with " | |
452 | "a Monday not at the beginning or end " | |
453 | "of the year") | |
454 | test_helper((1917, 12, 31), "Dec 31 on Monday with year starting and " | |
455 | "ending on Monday") | |
456 | ||
457 | ||
458 | class CacheTests(unittest.TestCase): | |
459 | """Test that caching works properly.""" | |
460 | ||
461 | def test_time_re_recreation(self): | |
462 | # Make sure cache is recreated when current locale does not match what | |
463 | # cached object was created with. | |
464 | _strptime.strptime("10", "%d") | |
465 | _strptime.strptime("2005", "%Y") | |
466 | _strptime._TimeRE_cache.locale_time.lang = "Ni" | |
467 | original_time_re = id(_strptime._TimeRE_cache) | |
468 | _strptime.strptime("10", "%d") | |
469 | self.failIfEqual(original_time_re, id(_strptime._TimeRE_cache)) | |
470 | self.failUnlessEqual(len(_strptime._regex_cache), 1) | |
471 | ||
472 | def test_regex_cleanup(self): | |
473 | # Make sure cached regexes are discarded when cache becomes "full". | |
474 | try: | |
475 | del _strptime._regex_cache['%d'] | |
476 | except KeyError: | |
477 | pass | |
478 | bogus_key = 0 | |
479 | while len(_strptime._regex_cache) <= _strptime._CACHE_MAX_SIZE: | |
480 | _strptime._regex_cache[bogus_key] = None | |
481 | bogus_key += 1 | |
482 | _strptime.strptime("10", "%d") | |
483 | self.failUnlessEqual(len(_strptime._regex_cache), 1) | |
484 | ||
485 | def test_new_localetime(self): | |
486 | # A new LocaleTime instance should be created when a new TimeRE object | |
487 | # is created. | |
488 | locale_time_id = id(_strptime._TimeRE_cache.locale_time) | |
489 | _strptime._TimeRE_cache.locale_time.lang = "Ni" | |
490 | _strptime.strptime("10", "%d") | |
491 | self.failIfEqual(locale_time_id, | |
492 | id(_strptime._TimeRE_cache.locale_time)) | |
493 | ||
494 | ||
495 | def test_main(): | |
496 | test_support.run_unittest( | |
497 | getlang_Tests, | |
498 | LocaleTime_Tests, | |
499 | TimeRETests, | |
500 | StrptimeTests, | |
501 | Strptime12AMPMTests, | |
502 | JulianTests, | |
503 | CalculationTests, | |
504 | CacheTests | |
505 | ) | |
506 | ||
507 | ||
508 | if __name__ == '__main__': | |
509 | test_main() |