blob: 20b0f810f4a204b694aa4fe2733fe7d2e32d6f91 [file] [log] [blame]
Brett Cannonf1cfb622003-05-04 21:15:27 +00001"""Supporting definitions for the Python regression tests."""
Guido van Rossum3bead091992-01-27 17:00:37 +00002
Benjamin Petersonee8712c2008-05-20 21:35:26 +00003if __name__ != 'test.support':
4 raise ImportError('support must be imported from the test package')
Barry Warsaw408b6d32002-07-30 23:27:12 +00005
Guido van Rossumd8faa362007-04-27 19:54:29 +00006import contextlib
7import errno
Benjamin Petersonfa0d7032009-06-01 22:42:33 +00008import functools
Benjamin Peterson8cc7d882009-06-01 23:14:51 +00009import gc
Guido van Rossumd8faa362007-04-27 19:54:29 +000010import socket
Fred Drakecd1b1dd2001-03-21 18:26:33 +000011import sys
Guido van Rossumd8faa362007-04-27 19:54:29 +000012import os
Benjamin Petersone549ead2009-03-28 21:42:05 +000013import platform
Christian Heimes23daade02008-02-25 12:39:23 +000014import shutil
Thomas Wouters902d6eb2007-01-09 23:18:33 +000015import warnings
Guido van Rossumd8faa362007-04-27 19:54:29 +000016import unittest
R. David Murraya21e4ca2009-03-31 23:16:50 +000017import importlib
Walter Dörwald155374d2009-05-01 19:58:58 +000018import collections
Florent Xiclunab14930c2010-03-13 15:26:44 +000019import re
Brian Curtind40e6f72010-07-08 21:39:08 +000020import subprocess
Barry Warsaw28a691b2010-04-17 00:19:56 +000021import imp
Benjamin Petersona6590e82010-04-11 21:22:10 +000022import time
Benjamin Peterson65c66ab2010-10-29 21:31:35 +000023import sysconfig
24
25
Victor Stinner45df8202010-04-28 22:31:17 +000026try:
27 import _thread
28except ImportError:
29 _thread = None
Fred Drakecd1b1dd2001-03-21 18:26:33 +000030
Barry Warsaw28a691b2010-04-17 00:19:56 +000031__all__ = [
32 "Error", "TestFailed", "ResourceDenied", "import_module",
33 "verbose", "use_resources", "max_memuse", "record_original_stdout",
34 "get_original_stdout", "unload", "unlink", "rmtree", "forget",
35 "is_resource_enabled", "requires", "find_unused_port", "bind_port",
36 "fcmp", "is_jython", "TESTFN", "HOST", "FUZZ", "SAVEDCWD", "temp_cwd",
37 "findfile", "sortdict", "check_syntax_error", "open_urlresource",
38 "check_warnings", "CleanImport", "EnvironmentVarGuard",
39 "TransientResource", "captured_output", "captured_stdout",
40 "time_out", "socket_peer_reset", "ioerror_peer_reset",
Antoine Pitroua88c83c2010-09-07 20:42:19 +000041 "run_with_locale", 'temp_umask', "transient_internet",
Barry Warsaw28a691b2010-04-17 00:19:56 +000042 "set_memlimit", "bigmemtest", "bigaddrspacetest", "BasicTestRunner",
43 "run_unittest", "run_doctest", "threading_setup", "threading_cleanup",
44 "reap_children", "cpython_only", "check_impl_detail", "get_attribute",
Eric Smith44588b42010-12-04 17:12:41 +000045 "swap_item", "swap_attr", "requires_IEEE_754"]
Benjamin Peterson744c2cd2008-05-26 16:26:37 +000046
Florent Xiclunaf089fd62010-03-19 14:25:03 +000047
Fred Drake1790dd42000-07-24 06:55:00 +000048class Error(Exception):
Fred Drake004d5e62000-10-23 17:22:08 +000049 """Base class for regression test exceptions."""
Fred Drake1790dd42000-07-24 06:55:00 +000050
51class TestFailed(Error):
Fred Drake004d5e62000-10-23 17:22:08 +000052 """Test failed."""
Fred Drake1790dd42000-07-24 06:55:00 +000053
Benjamin Petersone549ead2009-03-28 21:42:05 +000054class ResourceDenied(unittest.SkipTest):
Fred Drake9a0db072003-02-03 15:19:30 +000055 """Test skipped because it requested a disallowed resource.
56
57 This is raised when a test calls requires() for a resource that
58 has not be enabled. It is used to distinguish between expected
59 and unexpected skips.
60 """
61
Nick Coghlanfce769e2009-04-11 14:30:59 +000062@contextlib.contextmanager
63def _ignore_deprecated_imports(ignore=True):
64 """Context manager to suppress package and module deprecation
65 warnings when importing them.
66
67 If ignore is False, this context manager has no effect."""
68 if ignore:
69 with warnings.catch_warnings():
70 warnings.filterwarnings("ignore", ".+ (module|package)",
71 DeprecationWarning)
72 yield
73 else:
74 yield
75
76
Benjamin Peterson699adb92008-05-08 22:27:58 +000077def import_module(name, deprecated=False):
R. David Murraya21e4ca2009-03-31 23:16:50 +000078 """Import and return the module to be tested, raising SkipTest if
79 it is not available.
80
81 If deprecated is True, any module or package deprecation messages
82 will be suppressed."""
Nick Coghlanfce769e2009-04-11 14:30:59 +000083 with _ignore_deprecated_imports(deprecated):
Benjamin Peterson699adb92008-05-08 22:27:58 +000084 try:
Nick Coghlanfce769e2009-04-11 14:30:59 +000085 return importlib.import_module(name)
R. David Murraya21e4ca2009-03-31 23:16:50 +000086 except ImportError as msg:
87 raise unittest.SkipTest(str(msg))
Nick Coghlanfce769e2009-04-11 14:30:59 +000088
89
Nick Coghlan47384702009-04-22 16:13:36 +000090def _save_and_remove_module(name, orig_modules):
91 """Helper function to save and remove a module from sys.modules
92
93 Return value is True if the module was in sys.modules and
94 False otherwise."""
95 saved = True
96 try:
97 orig_modules[name] = sys.modules[name]
98 except KeyError:
99 saved = False
100 else:
101 del sys.modules[name]
102 return saved
103
104
105def _save_and_block_module(name, orig_modules):
106 """Helper function to save and block a module in sys.modules
107
108 Return value is True if the module was in sys.modules and
109 False otherwise."""
110 saved = True
111 try:
112 orig_modules[name] = sys.modules[name]
113 except KeyError:
114 saved = False
Alexander Belopolsky903396e2010-07-13 14:50:16 +0000115 sys.modules[name] = None
Nick Coghlan47384702009-04-22 16:13:36 +0000116 return saved
117
118
119def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
Nick Coghlanfce769e2009-04-11 14:30:59 +0000120 """Imports and returns a module, deliberately bypassing the sys.modules cache
121 and importing a fresh copy of the module. Once the import is complete,
122 the sys.modules cache is restored to its original state.
123
Nick Coghlan47384702009-04-22 16:13:36 +0000124 Modules named in fresh are also imported anew if needed by the import.
125
126 Importing of modules named in blocked is prevented while the fresh import
Nick Coghlanfce769e2009-04-11 14:30:59 +0000127 takes place.
128
129 If deprecated is True, any module or package deprecation messages
130 will be suppressed."""
131 # NOTE: test_heapq and test_warnings include extra sanity checks to make
132 # sure that this utility function is working as expected
133 with _ignore_deprecated_imports(deprecated):
Nick Coghlan47384702009-04-22 16:13:36 +0000134 # Keep track of modules saved for later restoration as well
135 # as those which just need a blocking entry removed
Nick Coghlanfce769e2009-04-11 14:30:59 +0000136 orig_modules = {}
Nick Coghlan47384702009-04-22 16:13:36 +0000137 names_to_remove = []
138 _save_and_remove_module(name, orig_modules)
Nick Coghlanfce769e2009-04-11 14:30:59 +0000139 try:
Nick Coghlan47384702009-04-22 16:13:36 +0000140 for fresh_name in fresh:
141 _save_and_remove_module(fresh_name, orig_modules)
142 for blocked_name in blocked:
143 if not _save_and_block_module(blocked_name, orig_modules):
144 names_to_remove.append(blocked_name)
145 fresh_module = importlib.import_module(name)
Nick Coghlanfce769e2009-04-11 14:30:59 +0000146 finally:
Nick Coghlan47384702009-04-22 16:13:36 +0000147 for orig_name, module in orig_modules.items():
148 sys.modules[orig_name] = module
149 for name_to_remove in names_to_remove:
150 del sys.modules[name_to_remove]
151 return fresh_module
Nick Coghlanfce769e2009-04-11 14:30:59 +0000152
Benjamin Peterson699adb92008-05-08 22:27:58 +0000153
R. David Murraya21e4ca2009-03-31 23:16:50 +0000154def get_attribute(obj, name):
155 """Get an attribute, raising SkipTest if AttributeError is raised."""
156 try:
157 attribute = getattr(obj, name)
158 except AttributeError:
159 raise unittest.SkipTest("module %s has no attribute %s" % (
160 obj.__name__, name))
161 else:
162 return attribute
163
Barry Warsawc0fb6052001-08-20 22:29:23 +0000164verbose = 1 # Flag set to 0 by regrtest.py
Thomas Wouters477c8d52006-05-27 19:21:47 +0000165use_resources = None # Flag set to [] by regrtest.py
166max_memuse = 0 # Disable bigmem tests (they will still be run with
167 # small sizes, to make sure they work.)
Neal Norwitz3ce5d922008-08-24 07:08:55 +0000168real_max_memuse = 0
Guido van Rossum531661c1996-12-20 02:58:22 +0000169
Tim Peters8dee8092001-09-25 20:05:11 +0000170# _original_stdout is meant to hold stdout at the time regrtest began.
171# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
172# The point is to have some flavor of stdout the user can actually see.
173_original_stdout = None
174def record_original_stdout(stdout):
175 global _original_stdout
176 _original_stdout = stdout
177
178def get_original_stdout():
179 return _original_stdout or sys.stdout
180
Guido van Rossum3bead091992-01-27 17:00:37 +0000181def unload(name):
Fred Drake004d5e62000-10-23 17:22:08 +0000182 try:
183 del sys.modules[name]
184 except KeyError:
185 pass
Guido van Rossum3bead091992-01-27 17:00:37 +0000186
Neal Norwitz0e17f8c2006-01-23 07:51:27 +0000187def unlink(filename):
Neal Norwitz0e17f8c2006-01-23 07:51:27 +0000188 try:
189 os.unlink(filename)
Barry Warsaw28a691b2010-04-17 00:19:56 +0000190 except OSError as error:
191 # The filename need not exist.
Michael Foord2d9c2d52010-05-04 22:29:10 +0000192 if error.errno not in (errno.ENOENT, errno.ENOTDIR):
Barry Warsaw28a691b2010-04-17 00:19:56 +0000193 raise
Neal Norwitz0e17f8c2006-01-23 07:51:27 +0000194
Christian Heimes23daade02008-02-25 12:39:23 +0000195def rmtree(path):
196 try:
197 shutil.rmtree(path)
Barry Warsaw28a691b2010-04-17 00:19:56 +0000198 except OSError as error:
Christian Heimes23daade02008-02-25 12:39:23 +0000199 # Unix returns ENOENT, Windows returns ESRCH.
Barry Warsaw28a691b2010-04-17 00:19:56 +0000200 if error.errno not in (errno.ENOENT, errno.ESRCH):
Christian Heimes23daade02008-02-25 12:39:23 +0000201 raise
202
Barry Warsaw28a691b2010-04-17 00:19:56 +0000203def make_legacy_pyc(source):
204 """Move a PEP 3147 pyc/pyo file to its legacy pyc/pyo location.
205
206 The choice of .pyc or .pyo extension is done based on the __debug__ flag
207 value.
208
209 :param source: The file system path to the source file. The source file
210 does not need to exist, however the PEP 3147 pyc file must exist.
211 :return: The file system path to the legacy pyc file.
212 """
213 pyc_file = imp.cache_from_source(source)
214 up_one = os.path.dirname(os.path.abspath(source))
215 legacy_pyc = os.path.join(up_one, source + ('c' if __debug__ else 'o'))
216 os.rename(pyc_file, legacy_pyc)
217 return legacy_pyc
218
Guido van Rossum3bead091992-01-27 17:00:37 +0000219def forget(modname):
Barry Warsaw28a691b2010-04-17 00:19:56 +0000220 """'Forget' a module was ever imported.
221
222 This removes the module from sys.modules and deletes any PEP 3147 or
223 legacy .pyc and .pyo files.
224 """
Fred Drake004d5e62000-10-23 17:22:08 +0000225 unload(modname)
Fred Drake004d5e62000-10-23 17:22:08 +0000226 for dirname in sys.path:
Barry Warsaw28a691b2010-04-17 00:19:56 +0000227 source = os.path.join(dirname, modname + '.py')
228 # It doesn't matter if they exist or not, unlink all possible
229 # combinations of PEP 3147 and legacy pyc and pyo files.
230 unlink(source + 'c')
231 unlink(source + 'o')
232 unlink(imp.cache_from_source(source, debug_override=True))
233 unlink(imp.cache_from_source(source, debug_override=False))
Guido van Rossum3bead091992-01-27 17:00:37 +0000234
Tim Petersb4ee4eb2002-12-04 03:26:57 +0000235def is_resource_enabled(resource):
Brett Cannonf1cfb622003-05-04 21:15:27 +0000236 """Test whether a resource is enabled. Known resources are set by
237 regrtest.py."""
Tim Petersb4ee4eb2002-12-04 03:26:57 +0000238 return use_resources is not None and resource in use_resources
239
Barry Warsawc0fb6052001-08-20 22:29:23 +0000240def requires(resource, msg=None):
Brett Cannonf1cfb622003-05-04 21:15:27 +0000241 """Raise ResourceDenied if the specified resource is not available.
242
243 If the caller's module is __main__ then automatically return True. The
Barry Warsaw28a691b2010-04-17 00:19:56 +0000244 possibility of False being returned occurs when regrtest.py is
245 executing.
246 """
Skip Montanarod839ecd2003-04-24 19:06:57 +0000247 # see if the caller's module is __main__ - if so, treat as if
248 # the resource was set
Benjamin Petersone549ead2009-03-28 21:42:05 +0000249 if sys._getframe(1).f_globals.get("__name__") == "__main__":
Skip Montanarod839ecd2003-04-24 19:06:57 +0000250 return
Tim Petersb4ee4eb2002-12-04 03:26:57 +0000251 if not is_resource_enabled(resource):
Barry Warsawc0fb6052001-08-20 22:29:23 +0000252 if msg is None:
253 msg = "Use of the `%s' resource not enabled" % resource
Fred Drake9a0db072003-02-03 15:19:30 +0000254 raise ResourceDenied(msg)
Barry Warsawc0fb6052001-08-20 22:29:23 +0000255
Christian Heimes5e696852008-04-09 08:37:03 +0000256HOST = 'localhost'
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000257
Christian Heimes5e696852008-04-09 08:37:03 +0000258def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM):
259 """Returns an unused port that should be suitable for binding. This is
260 achieved by creating a temporary socket with the same family and type as
261 the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to
262 the specified host address (defaults to 0.0.0.0) with the port set to 0,
263 eliciting an unused ephemeral port from the OS. The temporary socket is
264 then closed and deleted, and the ephemeral port is returned.
265
266 Either this method or bind_port() should be used for any tests where a
267 server socket needs to be bound to a particular port for the duration of
268 the test. Which one to use depends on whether the calling code is creating
269 a python socket, or if an unused port needs to be provided in a constructor
270 or passed to an external program (i.e. the -accept argument to openssl's
271 s_server mode). Always prefer bind_port() over find_unused_port() where
272 possible. Hard coded ports should *NEVER* be used. As soon as a server
273 socket is bound to a hard coded port, the ability to run multiple instances
274 of the test simultaneously on the same host is compromised, which makes the
275 test a ticking time bomb in a buildbot environment. On Unix buildbots, this
276 may simply manifest as a failed test, which can be recovered from without
277 intervention in most cases, but on Windows, the entire python process can
278 completely and utterly wedge, requiring someone to log in to the buildbot
279 and manually kill the affected process.
280
281 (This is easy to reproduce on Windows, unfortunately, and can be traced to
282 the SO_REUSEADDR socket option having different semantics on Windows versus
283 Unix/Linux. On Unix, you can't have two AF_INET SOCK_STREAM sockets bind,
284 listen and then accept connections on identical host/ports. An EADDRINUSE
285 socket.error will be raised at some point (depending on the platform and
286 the order bind and listen were called on each socket).
287
288 However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE
289 will ever be raised when attempting to bind two identical host/ports. When
290 accept() is called on each socket, the second caller's process will steal
291 the port from the first caller, leaving them both in an awkwardly wedged
292 state where they'll no longer respond to any signals or graceful kills, and
293 must be forcibly killed via OpenProcess()/TerminateProcess().
294
295 The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option
296 instead of SO_REUSEADDR, which effectively affords the same semantics as
297 SO_REUSEADDR on Unix. Given the propensity of Unix developers in the Open
298 Source world compared to Windows ones, this is a common mistake. A quick
299 look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when
300 openssl.exe is called with the 's_server' option, for example. See
301 http://bugs.python.org/issue2550 for more info. The following site also
302 has a very thorough description about the implications of both REUSEADDR
303 and EXCLUSIVEADDRUSE on Windows:
304 http://msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx)
305
306 XXX: although this approach is a vast improvement on previous attempts to
307 elicit unused ports, it rests heavily on the assumption that the ephemeral
308 port returned to us by the OS won't immediately be dished back out to some
309 other process when we close and delete our temporary socket but before our
310 calling code has a chance to bind the returned port. We can deal with this
311 issue if/when we come across it.
312 """
313
314 tempsock = socket.socket(family, socktype)
315 port = bind_port(tempsock)
316 tempsock.close()
317 del tempsock
318 return port
319
320def bind_port(sock, host=HOST):
321 """Bind the socket to a free port and return the port number. Relies on
322 ephemeral ports in order to ensure we are using an unbound port. This is
323 important as many tests may be running simultaneously, especially in a
324 buildbot environment. This method raises an exception if the sock.family
325 is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
326 or SO_REUSEPORT set on it. Tests should *never* set these socket options
327 for TCP/IP sockets. The only case for setting these options is testing
328 multicasting via multiple UDP sockets.
329
330 Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
331 on Windows), it will be set on the socket. This will prevent anyone else
332 from bind()'ing to our host/port for the duration of the test.
333 """
334
335 if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
336 if hasattr(socket, 'SO_REUSEADDR'):
337 if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
338 raise TestFailed("tests should never set the SO_REUSEADDR " \
339 "socket option on TCP/IP sockets!")
340 if hasattr(socket, 'SO_REUSEPORT'):
341 if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
342 raise TestFailed("tests should never set the SO_REUSEPORT " \
343 "socket option on TCP/IP sockets!")
344 if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
345 sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
346
347 sock.bind((host, 0))
348 port = sock.getsockname()[1]
349 return port
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000350
Guido van Rossum35fb82a1993-01-26 13:04:43 +0000351FUZZ = 1e-6
352
353def fcmp(x, y): # fuzzy comparison function
Neal Norwitz79212992006-08-21 16:27:31 +0000354 if isinstance(x, float) or isinstance(y, float):
Fred Drake004d5e62000-10-23 17:22:08 +0000355 try:
Fred Drake004d5e62000-10-23 17:22:08 +0000356 fuzz = (abs(x) + abs(y)) * FUZZ
357 if abs(x-y) <= fuzz:
358 return 0
359 except:
360 pass
Neal Norwitz79212992006-08-21 16:27:31 +0000361 elif type(x) == type(y) and isinstance(x, (tuple, list)):
Fred Drake004d5e62000-10-23 17:22:08 +0000362 for i in range(min(len(x), len(y))):
363 outcome = fcmp(x[i], y[i])
Fred Drake132dce22000-12-12 23:11:42 +0000364 if outcome != 0:
Fred Drake004d5e62000-10-23 17:22:08 +0000365 return outcome
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000366 return (len(x) > len(y)) - (len(x) < len(y))
367 return (x > y) - (x < y)
Guido van Rossum35fb82a1993-01-26 13:04:43 +0000368
Eric Smithf24a0d92010-12-04 13:32:18 +0000369# decorator for skipping tests on non-IEEE 754 platforms
370requires_IEEE_754 = unittest.skipUnless(
371 float.__getformat__("double").startswith("IEEE"),
372 "test requires IEEE 754 doubles")
373
Finn Bock57bc5fa2002-11-01 18:02:03 +0000374is_jython = sys.platform.startswith('java')
375
Barry Warsaw559f6682001-03-23 18:04:02 +0000376# Filename used for testing
377if os.name == 'java':
378 # Jython disallows @ in module names
379 TESTFN = '$test'
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000380else:
Barry Warsaw559f6682001-03-23 18:04:02 +0000381 TESTFN = '@test'
Walter Dörwald9b775532007-06-08 14:30:53 +0000382
Antoine Pitrou88909542009-06-29 13:54:42 +0000383# Disambiguate TESTFN for parallel testing, while letting it remain a valid
384# module name.
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000385TESTFN = "{}_{}_tmp".format(TESTFN, os.getpid())
Antoine Pitrou88909542009-06-29 13:54:42 +0000386
Michael Foord2d9c2d52010-05-04 22:29:10 +0000387
Victor Stinnerd91df1a2010-08-18 10:56:19 +0000388# TESTFN_UNICODE is a non-ascii filename
389TESTFN_UNICODE = TESTFN + "-\xe0\xf2\u0258\u0141\u011f"
Victor Stinner74a833f2010-08-18 21:06:23 +0000390if sys.platform == 'darwin':
391 # In Mac OS X's VFS API file names are, by definition, canonically
392 # decomposed Unicode, encoded using UTF-8. See QA1173:
393 # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
394 import unicodedata
395 TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE)
Antoine Pitrou88909542009-06-29 13:54:42 +0000396TESTFN_ENCODING = sys.getfilesystemencoding()
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000397
Victor Stinner09c449c2010-08-13 22:23:24 +0000398# TESTFN_UNENCODABLE is a filename (str type) that should *not* be able to be
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000399# encoded by the filesystem encoding (in strict mode). It can be None if we
400# cannot generate such filename.
Victor Stinnera0241c82010-08-15 19:28:21 +0000401TESTFN_UNENCODABLE = None
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000402if os.name in ('nt', 'ce'):
Victor Stinnera0241c82010-08-15 19:28:21 +0000403 # skip win32s (0) or Windows 9x/ME (1)
404 if sys.getwindowsversion().platform >= 2:
Victor Stinner8ce7df62010-09-10 11:19:59 +0000405 # Different kinds of characters from various languages to minimize the
406 # probability that the whole name is encodable to MBCS (issue #9819)
407 TESTFN_UNENCODABLE = TESTFN + "-\u5171\u0141\u2661\u0363\uDC80"
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000408 try:
Victor Stinner09c449c2010-08-13 22:23:24 +0000409 TESTFN_UNENCODABLE.encode(TESTFN_ENCODING)
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000410 except UnicodeEncodeError:
411 pass
412 else:
413 print('WARNING: The filename %r CAN be encoded by the filesystem encoding (%s). '
414 'Unicode filename tests may not be effective'
Victor Stinner09c449c2010-08-13 22:23:24 +0000415 % (TESTFN_UNENCODABLE, TESTFN_ENCODING))
416 TESTFN_UNENCODABLE = None
Victor Stinnera0241c82010-08-15 19:28:21 +0000417# Mac OS X denies unencodable filenames (invalid utf-8)
Victor Stinner03c9e1d2010-08-14 17:35:20 +0000418elif sys.platform != 'darwin':
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000419 try:
420 # ascii and utf-8 cannot encode the byte 0xff
421 b'\xff'.decode(TESTFN_ENCODING)
422 except UnicodeDecodeError:
423 # 0xff will be encoded using the surrogate character u+DCFF
Victor Stinner09c449c2010-08-13 22:23:24 +0000424 TESTFN_UNENCODABLE = TESTFN \
Victor Stinner3d85a6f2010-08-13 13:02:04 +0000425 + b'-\xff'.decode(TESTFN_ENCODING, 'surrogateescape')
426 else:
427 # File system encoding (eg. ISO-8859-* encodings) can encode
428 # the byte 0xff. Skip some unicode filename tests.
Victor Stinnera0241c82010-08-15 19:28:21 +0000429 pass
Neal Norwitz26a1eef2002-11-03 00:35:53 +0000430
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000431# Save the initial cwd
432SAVEDCWD = os.getcwd()
433
434@contextlib.contextmanager
Nick Coghland26c18a2010-08-17 13:06:11 +0000435def temp_cwd(name='tempcwd', quiet=False, path=None):
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000436 """
Nick Coghland26c18a2010-08-17 13:06:11 +0000437 Context manager that temporarily changes the CWD.
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000438
Nick Coghland26c18a2010-08-17 13:06:11 +0000439 An existing path may be provided as *path*, in which case this
440 function makes no changes to the file system.
441
442 Otherwise, the new CWD is created in the current directory and it's
443 named *name*. If *quiet* is False (default) and it's not possible to
444 create or change the CWD, an error is raised. If it's True, only a
445 warning is raised and the original CWD is used.
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000446 """
447 saved_dir = os.getcwd()
448 is_temporary = False
Nick Coghland26c18a2010-08-17 13:06:11 +0000449 if path is None:
450 path = name
451 try:
452 os.mkdir(name)
453 is_temporary = True
454 except OSError:
455 if not quiet:
456 raise
457 warnings.warn('tests may fail, unable to create temp CWD ' + name,
458 RuntimeWarning, stacklevel=3)
Neal Norwitz26a1eef2002-11-03 00:35:53 +0000459 try:
Nick Coghland26c18a2010-08-17 13:06:11 +0000460 os.chdir(path)
Ezio Melotti184bdfb2010-02-18 09:37:05 +0000461 except OSError:
462 if not quiet:
463 raise
464 warnings.warn('tests may fail, unable to change the CWD to ' + name,
465 RuntimeWarning, stacklevel=3)
466 try:
467 yield os.getcwd()
468 finally:
469 os.chdir(saved_dir)
470 if is_temporary:
471 rmtree(name)
472
Guido van Rossuma8f7e592001-03-13 09:31:07 +0000473
Barry Warsaw28a691b2010-04-17 00:19:56 +0000474@contextlib.contextmanager
475def temp_umask(umask):
476 """Context manager that temporarily sets the process umask."""
477 oldmask = os.umask(umask)
478 try:
479 yield
480 finally:
481 os.umask(oldmask)
482
483
Florent Xiclunaf15351d2010-03-13 23:24:31 +0000484def findfile(file, here=__file__, subdir=None):
Brett Cannonf1cfb622003-05-04 21:15:27 +0000485 """Try to find a file on sys.path and the working directory. If it is not
486 found the argument passed to the function is returned (this does not
487 necessarily signal failure; could still be the legitimate path)."""
Fred Drake004d5e62000-10-23 17:22:08 +0000488 if os.path.isabs(file):
489 return file
Florent Xiclunaf15351d2010-03-13 23:24:31 +0000490 if subdir is not None:
491 file = os.path.join(subdir, file)
Fred Drake004d5e62000-10-23 17:22:08 +0000492 path = sys.path
493 path = [os.path.dirname(here)] + path
494 for dn in path:
495 fn = os.path.join(dn, file)
496 if os.path.exists(fn): return fn
497 return file
Marc-André Lemburg36619082001-01-17 19:11:13 +0000498
Tim Peters2f228e72001-05-13 00:19:31 +0000499def sortdict(dict):
500 "Like repr(dict), but in sorted order."
Guido van Rossumcc2b0162007-02-11 06:12:03 +0000501 items = sorted(dict.items())
Tim Peters2f228e72001-05-13 00:19:31 +0000502 reprpairs = ["%r: %r" % pair for pair in items]
503 withcommas = ", ".join(reprpairs)
504 return "{%s}" % withcommas
505
Benjamin Peterson7522c742009-01-19 21:00:09 +0000506def make_bad_fd():
507 """
508 Create an invalid file descriptor by opening and closing a file and return
509 its fd.
510 """
511 file = open(TESTFN, "wb")
512 try:
513 return file.fileno()
514 finally:
515 file.close()
516 unlink(TESTFN)
517
Thomas Wouters89f507f2006-12-13 04:49:30 +0000518def check_syntax_error(testcase, statement):
Benjamin Petersone549ead2009-03-28 21:42:05 +0000519 testcase.assertRaises(SyntaxError, compile, statement,
520 '<test string>', 'exec')
Fred Drakecd1b1dd2001-03-21 18:26:33 +0000521
Martin v. Löwis234a34a2007-08-30 20:58:02 +0000522def open_urlresource(url, *args, **kw):
Jeremy Hylton1afc1692008-06-18 20:49:58 +0000523 import urllib.request, urllib.parse
Fred Drakecd1b1dd2001-03-21 18:26:33 +0000524
Florent Xiclunaf089fd62010-03-19 14:25:03 +0000525 check = kw.pop('check', None)
526
Jeremy Hylton1afc1692008-06-18 20:49:58 +0000527 filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
Hye-Shik Changaaa2f1d2005-12-10 17:44:27 +0000528
Alexandre Vassalotti711ed4a2009-07-17 10:42:05 +0000529 fn = os.path.join(os.path.dirname(__file__), "data", filename)
Florent Xiclunaf089fd62010-03-19 14:25:03 +0000530
531 def check_valid_file(fn):
532 f = open(fn, *args, **kw)
533 if check is None:
534 return f
535 elif check(f):
536 f.seek(0)
537 return f
538 f.close()
539
Alexandre Vassalotti711ed4a2009-07-17 10:42:05 +0000540 if os.path.exists(fn):
Florent Xiclunaf089fd62010-03-19 14:25:03 +0000541 f = check_valid_file(fn)
542 if f is not None:
543 return f
544 unlink(fn)
545
546 # Verify the requirement before downloading the file
547 requires('urlfetch')
Hye-Shik Changaaa2f1d2005-12-10 17:44:27 +0000548
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000549 print('\tfetching %s ...' % url, file=get_original_stdout())
Antoine Pitroufd0680b2009-11-01 22:13:48 +0000550 f = urllib.request.urlopen(url, timeout=15)
551 try:
552 with open(fn, "wb") as out:
553 s = f.read()
554 while s:
555 out.write(s)
556 s = f.read()
557 finally:
558 f.close()
Florent Xiclunaf089fd62010-03-19 14:25:03 +0000559
560 f = check_valid_file(fn)
561 if f is not None:
562 return f
563 raise TestFailed('invalid resource "%s"' % fn)
564
Thomas Wouters9fe394c2007-02-05 01:24:16 +0000565
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000566class WarningsRecorder(object):
567 """Convenience wrapper for the warnings list returned on
568 entry to the warnings.catch_warnings() context manager.
Guido van Rossumd8faa362007-04-27 19:54:29 +0000569 """
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000570 def __init__(self, warnings_list):
Florent Xiclunab14930c2010-03-13 15:26:44 +0000571 self._warnings = warnings_list
572 self._last = 0
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000573
574 def __getattr__(self, attr):
Florent Xiclunab14930c2010-03-13 15:26:44 +0000575 if len(self._warnings) > self._last:
576 return getattr(self._warnings[-1], attr)
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000577 elif attr in warnings.WarningMessage._WARNING_DETAILS:
578 return None
579 raise AttributeError("%r has no attribute %r" % (self, attr))
580
Florent Xiclunab14930c2010-03-13 15:26:44 +0000581 @property
582 def warnings(self):
583 return self._warnings[self._last:]
584
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000585 def reset(self):
Florent Xiclunab14930c2010-03-13 15:26:44 +0000586 self._last = len(self._warnings)
587
588
589def _filterwarnings(filters, quiet=False):
590 """Catch the warnings, then check if all the expected
591 warnings have been raised and re-raise unexpected warnings.
592 If 'quiet' is True, only re-raise the unexpected warnings.
593 """
594 # Clear the warning registry of the calling module
595 # in order to re-raise the warnings.
596 frame = sys._getframe(2)
597 registry = frame.f_globals.get('__warningregistry__')
598 if registry:
599 registry.clear()
600 with warnings.catch_warnings(record=True) as w:
601 # Set filter "always" to record all warnings. Because
602 # test_warnings swap the module, we need to look up in
603 # the sys.modules dictionary.
604 sys.modules['warnings'].simplefilter("always")
605 yield WarningsRecorder(w)
606 # Filter the recorded warnings
Antoine Pitrou31e08a42010-10-29 11:54:03 +0000607 reraise = list(w)
Florent Xiclunab14930c2010-03-13 15:26:44 +0000608 missing = []
609 for msg, cat in filters:
610 seen = False
Antoine Pitrou31e08a42010-10-29 11:54:03 +0000611 for w in reraise[:]:
612 warning = w.message
Florent Xiclunab14930c2010-03-13 15:26:44 +0000613 # Filter out the matching messages
Antoine Pitrou31e08a42010-10-29 11:54:03 +0000614 if (re.match(msg, str(warning), re.I) and
615 issubclass(warning.__class__, cat)):
Florent Xiclunab14930c2010-03-13 15:26:44 +0000616 seen = True
Antoine Pitrou31e08a42010-10-29 11:54:03 +0000617 reraise.remove(w)
Florent Xiclunab14930c2010-03-13 15:26:44 +0000618 if not seen and not quiet:
619 # This filter caught nothing
620 missing.append((msg, cat.__name__))
621 if reraise:
Antoine Pitrou31e08a42010-10-29 11:54:03 +0000622 raise AssertionError("unhandled warning %s" % reraise[0])
Florent Xiclunab14930c2010-03-13 15:26:44 +0000623 if missing:
624 raise AssertionError("filter (%r, %s) did not catch any warning" %
625 missing[0])
626
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000627
628@contextlib.contextmanager
Florent Xiclunab14930c2010-03-13 15:26:44 +0000629def check_warnings(*filters, **kwargs):
630 """Context manager to silence warnings.
631
632 Accept 2-tuples as positional arguments:
633 ("message regexp", WarningCategory)
634
635 Optional argument:
636 - if 'quiet' is True, it does not fail if a filter catches nothing
Florent Xicluna53b506be2010-03-18 20:00:57 +0000637 (default True without argument,
638 default False if some filters are defined)
Florent Xiclunab14930c2010-03-13 15:26:44 +0000639
640 Without argument, it defaults to:
Florent Xicluna53b506be2010-03-18 20:00:57 +0000641 check_warnings(("", Warning), quiet=True)
Florent Xiclunab14930c2010-03-13 15:26:44 +0000642 """
Florent Xicluna53b506be2010-03-18 20:00:57 +0000643 quiet = kwargs.get('quiet')
Florent Xiclunab14930c2010-03-13 15:26:44 +0000644 if not filters:
645 filters = (("", Warning),)
Florent Xicluna53b506be2010-03-18 20:00:57 +0000646 # Preserve backward compatibility
647 if quiet is None:
648 quiet = True
649 return _filterwarnings(filters, quiet)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000650
Alexandre Vassalotti5f8ced22008-05-16 00:03:33 +0000651
652class CleanImport(object):
653 """Context manager to force import to return a new module reference.
654
655 This is useful for testing module-level behaviours, such as
Nick Coghlanb1304932008-07-13 12:25:08 +0000656 the emission of a DeprecationWarning on import.
Alexandre Vassalotti5f8ced22008-05-16 00:03:33 +0000657
658 Use like this:
659
660 with CleanImport("foo"):
Brett Cannonddb5e702010-02-03 22:16:11 +0000661 importlib.import_module("foo") # new reference
Alexandre Vassalotti5f8ced22008-05-16 00:03:33 +0000662 """
663
664 def __init__(self, *module_names):
665 self.original_modules = sys.modules.copy()
666 for module_name in module_names:
667 if module_name in sys.modules:
668 module = sys.modules[module_name]
669 # It is possible that module_name is just an alias for
670 # another module (e.g. stub for modules renamed in 3.x).
671 # In that case, we also need delete the real module to clear
672 # the import cache.
673 if module.__name__ != module_name:
674 del sys.modules[module.__name__]
675 del sys.modules[module_name]
676
677 def __enter__(self):
678 return self
679
680 def __exit__(self, *ignore_exc):
681 sys.modules.update(self.original_modules)
682
683
Walter Dörwald155374d2009-05-01 19:58:58 +0000684class EnvironmentVarGuard(collections.MutableMapping):
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000685
686 """Class to help protect the environment variable properly. Can be used as
687 a context manager."""
688
689 def __init__(self):
Walter Dörwald155374d2009-05-01 19:58:58 +0000690 self._environ = os.environ
Walter Dörwald4ba80132009-04-25 12:48:43 +0000691 self._changed = {}
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000692
Walter Dörwald155374d2009-05-01 19:58:58 +0000693 def __getitem__(self, envvar):
694 return self._environ[envvar]
695
696 def __setitem__(self, envvar, value):
Walter Dörwald4ba80132009-04-25 12:48:43 +0000697 # Remember the initial value on the first access
698 if envvar not in self._changed:
Walter Dörwald155374d2009-05-01 19:58:58 +0000699 self._changed[envvar] = self._environ.get(envvar)
700 self._environ[envvar] = value
701
702 def __delitem__(self, envvar):
703 # Remember the initial value on the first access
704 if envvar not in self._changed:
705 self._changed[envvar] = self._environ.get(envvar)
706 if envvar in self._environ:
707 del self._environ[envvar]
708
709 def keys(self):
710 return self._environ.keys()
711
712 def __iter__(self):
713 return iter(self._environ)
714
715 def __len__(self):
716 return len(self._environ)
717
718 def set(self, envvar, value):
719 self[envvar] = value
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000720
721 def unset(self, envvar):
Walter Dörwald155374d2009-05-01 19:58:58 +0000722 del self[envvar]
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000723
724 def __enter__(self):
725 return self
726
727 def __exit__(self, *ignore_exc):
Walter Dörwald4ba80132009-04-25 12:48:43 +0000728 for (k, v) in self._changed.items():
729 if v is None:
Walter Dörwald155374d2009-05-01 19:58:58 +0000730 if k in self._environ:
731 del self._environ[k]
Walter Dörwald4ba80132009-04-25 12:48:43 +0000732 else:
Walter Dörwald155374d2009-05-01 19:58:58 +0000733 self._environ[k] = v
Nick Coghlan6ead5522009-10-18 13:19:33 +0000734 os.environ = self._environ
735
736
737class DirsOnSysPath(object):
738 """Context manager to temporarily add directories to sys.path.
739
740 This makes a copy of sys.path, appends any directories given
741 as positional arguments, then reverts sys.path to the copied
742 settings when the context ends.
743
744 Note that *all* sys.path modifications in the body of the
745 context manager, including replacement of the object,
746 will be reverted at the end of the block.
747 """
748
749 def __init__(self, *paths):
750 self.original_value = sys.path[:]
751 self.original_object = sys.path
752 sys.path.extend(paths)
753
754 def __enter__(self):
755 return self
756
757 def __exit__(self, *ignore_exc):
758 sys.path = self.original_object
759 sys.path[:] = self.original_value
Walter Dörwald155374d2009-05-01 19:58:58 +0000760
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000761
Guido van Rossumd8faa362007-04-27 19:54:29 +0000762class TransientResource(object):
763
764 """Raise ResourceDenied if an exception is raised while the context manager
765 is in effect that matches the specified exception and attributes."""
766
767 def __init__(self, exc, **kwargs):
768 self.exc = exc
769 self.attrs = kwargs
770
771 def __enter__(self):
772 return self
773
774 def __exit__(self, type_=None, value=None, traceback=None):
775 """If type_ is a subclass of self.exc and value has attributes matching
776 self.attrs, raise ResourceDenied. Otherwise let the exception
777 propagate (if any)."""
778 if type_ is not None and issubclass(self.exc, type_):
779 for attr, attr_value in self.attrs.items():
780 if not hasattr(value, attr):
781 break
782 if getattr(value, attr) != attr_value:
783 break
784 else:
785 raise ResourceDenied("an optional resource is not available")
786
Raymond Hettinger686057b2009-06-04 00:11:54 +0000787# Context managers that raise ResourceDenied when various issues
788# with the Internet connection manifest themselves as exceptions.
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000789# XXX deprecate these and use transient_internet() instead
Raymond Hettinger686057b2009-06-04 00:11:54 +0000790time_out = TransientResource(IOError, errno=errno.ETIMEDOUT)
791socket_peer_reset = TransientResource(socket.error, errno=errno.ECONNRESET)
792ioerror_peer_reset = TransientResource(IOError, errno=errno.ECONNRESET)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000793
Fred Drakecd1b1dd2001-03-21 18:26:33 +0000794
Thomas Woutersed03b412007-08-28 21:37:11 +0000795@contextlib.contextmanager
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000796def transient_internet(resource_name, *, timeout=30.0, errnos=()):
Antoine Pitroufec12ff2010-04-21 19:46:23 +0000797 """Return a context manager that raises ResourceDenied when various issues
798 with the Internet connection manifest themselves as exceptions."""
Antoine Pitrou8bc09032010-09-07 21:09:09 +0000799 default_errnos = [
800 ('ECONNREFUSED', 111),
801 ('ECONNRESET', 104),
802 ('ENETUNREACH', 101),
803 ('ETIMEDOUT', 110),
804 ]
Antoine Pitrou2673c5b2010-09-07 21:43:31 +0000805 default_gai_errnos = [
806 ('EAI_NONAME', -2),
807 ('EAI_NODATA', -5),
808 ]
Antoine Pitrou8bc09032010-09-07 21:09:09 +0000809
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000810 denied = ResourceDenied("Resource '%s' is not available" % resource_name)
Antoine Pitrou8bc09032010-09-07 21:09:09 +0000811 captured_errnos = errnos
Antoine Pitrou2673c5b2010-09-07 21:43:31 +0000812 gai_errnos = []
Antoine Pitrou8bc09032010-09-07 21:09:09 +0000813 if not captured_errnos:
814 captured_errnos = [getattr(errno, name, num)
815 for (name, num) in default_errnos]
Antoine Pitrou2673c5b2010-09-07 21:43:31 +0000816 gai_errnos = [getattr(socket, name, num)
817 for (name, num) in default_gai_errnos]
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000818
819 def filter_error(err):
Antoine Pitrou2673c5b2010-09-07 21:43:31 +0000820 n = getattr(err, 'errno', None)
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000821 if (isinstance(err, socket.timeout) or
Antoine Pitrou2673c5b2010-09-07 21:43:31 +0000822 (isinstance(err, socket.gaierror) and n in gai_errnos) or
823 n in captured_errnos):
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000824 if not verbose:
825 sys.stderr.write(denied.args[0] + "\n")
826 raise denied from err
827
828 old_timeout = socket.getdefaulttimeout()
829 try:
830 if timeout is not None:
831 socket.setdefaulttimeout(timeout)
Antoine Pitroufec12ff2010-04-21 19:46:23 +0000832 yield
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000833 except IOError as err:
Antoine Pitrou8bc09032010-09-07 21:09:09 +0000834 # urllib can wrap original socket errors multiple times (!), we must
835 # unwrap to get at the original error.
836 while True:
837 a = err.args
838 if len(a) >= 1 and isinstance(a[0], IOError):
839 err = a[0]
840 # The error can also be wrapped as args[1]:
841 # except socket.error as msg:
842 # raise IOError('socket error', msg).with_traceback(sys.exc_info()[2])
843 elif len(a) >= 2 and isinstance(a[1], IOError):
844 err = a[1]
845 else:
846 break
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000847 filter_error(err)
Antoine Pitroua88c83c2010-09-07 20:42:19 +0000848 raise
849 # XXX should we catch generic exceptions and look for their
850 # __cause__ or __context__?
851 finally:
852 socket.setdefaulttimeout(old_timeout)
Antoine Pitroufec12ff2010-04-21 19:46:23 +0000853
854
855@contextlib.contextmanager
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000856def captured_output(stream_name):
857 """Run the 'with' statement body using a StringIO object in place of a
858 specific attribute on the sys module.
859 Example use (with 'stream_name=stdout')::
Thomas Woutersed03b412007-08-28 21:37:11 +0000860
861 with captured_stdout() as s:
Neal Norwitz752abd02008-05-13 04:55:24 +0000862 print("hello")
Thomas Woutersed03b412007-08-28 21:37:11 +0000863 assert s.getvalue() == "hello"
864 """
865 import io
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000866 orig_stdout = getattr(sys, stream_name)
867 setattr(sys, stream_name, io.StringIO())
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000868 try:
869 yield getattr(sys, stream_name)
870 finally:
871 setattr(sys, stream_name, orig_stdout)
Benjamin Petersonad9d48d2008-04-02 21:49:44 +0000872
873def captured_stdout():
874 return captured_output("stdout")
Thomas Woutersed03b412007-08-28 21:37:11 +0000875
Nick Coghlan6ead5522009-10-18 13:19:33 +0000876def captured_stdin():
877 return captured_output("stdin")
878
Benjamin Petersone549ead2009-03-28 21:42:05 +0000879def gc_collect():
880 """Force as many objects as possible to be collected.
881
882 In non-CPython implementations of Python, this is needed because timely
883 deallocation is not guaranteed by the garbage collector. (Even in CPython
884 this can be the case in case of reference cycles.) This means that __del__
885 methods may be called later than expected and weakrefs may remain alive for
886 longer than expected. This function tries its best to force all garbage
887 objects to disappear.
888 """
Benjamin Petersone549ead2009-03-28 21:42:05 +0000889 gc.collect()
Benjamin Petersona6590e82010-04-11 21:22:10 +0000890 if is_jython:
891 time.sleep(0.1)
Benjamin Petersone549ead2009-03-28 21:42:05 +0000892 gc.collect()
893 gc.collect()
894
Thomas Woutersed03b412007-08-28 21:37:11 +0000895
Benjamin Peterson65c66ab2010-10-29 21:31:35 +0000896def python_is_optimized():
897 """Find if Python was built with optimizations."""
Antoine Pitrou64474542010-10-31 11:34:47 +0000898 cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
Benjamin Peterson65c66ab2010-10-29 21:31:35 +0000899 final_opt = ""
900 for opt in cflags.split():
901 if opt.startswith('-O'):
902 final_opt = opt
903 return final_opt and final_opt != '-O0'
904
905
Fred Drakecd1b1dd2001-03-21 18:26:33 +0000906#=======================================================================
Thomas Wouters477c8d52006-05-27 19:21:47 +0000907# Decorator for running a function in a different locale, correctly resetting
908# it afterwards.
909
910def run_with_locale(catstr, *locales):
911 def decorator(func):
912 def inner(*args, **kwds):
913 try:
914 import locale
915 category = getattr(locale, catstr)
916 orig_locale = locale.setlocale(category)
917 except AttributeError:
918 # if the test author gives us an invalid category string
919 raise
920 except:
921 # cannot retrieve original locale, so do nothing
922 locale = orig_locale = None
923 else:
924 for loc in locales:
925 try:
926 locale.setlocale(category, loc)
927 break
928 except:
929 pass
930
931 # now run the function, resetting the locale on exceptions
932 try:
933 return func(*args, **kwds)
934 finally:
935 if locale and orig_locale:
936 locale.setlocale(category, orig_locale)
Neal Norwitz221085d2007-02-25 20:55:47 +0000937 inner.__name__ = func.__name__
Thomas Wouters477c8d52006-05-27 19:21:47 +0000938 inner.__doc__ = func.__doc__
939 return inner
940 return decorator
941
942#=======================================================================
Georg Brandldb028442008-02-05 20:48:58 +0000943# Big-memory-test support. Separate from 'resources' because memory use
944# should be configurable.
Thomas Wouters477c8d52006-05-27 19:21:47 +0000945
946# Some handy shorthands. Note that these are used for byte-limits as well
947# as size-limits, in the various bigmem tests
948_1M = 1024*1024
949_1G = 1024 * _1M
950_2G = 2 * _1G
Neal Norwitz3ce5d922008-08-24 07:08:55 +0000951_4G = 4 * _1G
Thomas Wouters477c8d52006-05-27 19:21:47 +0000952
Thomas Woutersd2cf20e2007-08-30 22:57:53 +0000953MAX_Py_ssize_t = sys.maxsize
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000954
Thomas Wouters477c8d52006-05-27 19:21:47 +0000955def set_memlimit(limit):
Thomas Wouters477c8d52006-05-27 19:21:47 +0000956 global max_memuse
Neal Norwitz3ce5d922008-08-24 07:08:55 +0000957 global real_max_memuse
Thomas Wouters477c8d52006-05-27 19:21:47 +0000958 sizes = {
959 'k': 1024,
960 'm': _1M,
961 'g': _1G,
962 't': 1024*_1G,
963 }
964 m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
965 re.IGNORECASE | re.VERBOSE)
966 if m is None:
967 raise ValueError('Invalid memory limit %r' % (limit,))
968 memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
Neal Norwitz3ce5d922008-08-24 07:08:55 +0000969 real_max_memuse = memlimit
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000970 if memlimit > MAX_Py_ssize_t:
971 memlimit = MAX_Py_ssize_t
972 if memlimit < _2G - 1:
Thomas Wouters477c8d52006-05-27 19:21:47 +0000973 raise ValueError('Memory limit %r too low to be useful' % (limit,))
974 max_memuse = memlimit
975
976def bigmemtest(minsize, memuse, overhead=5*_1M):
977 """Decorator for bigmem tests.
978
979 'minsize' is the minimum useful size for the test (in arbitrary,
980 test-interpreted units.) 'memuse' is the number of 'bytes per size' for
981 the test, or a good estimate of it. 'overhead' specifies fixed overhead,
Christian Heimes33fe8092008-04-13 13:53:33 +0000982 independent of the testsize, and defaults to 5Mb.
Thomas Wouters477c8d52006-05-27 19:21:47 +0000983
984 The decorator tries to guess a good value for 'size' and passes it to
985 the decorated test function. If minsize * memuse is more than the
986 allowed memory use (as defined by max_memuse), the test is skipped.
987 Otherwise, minsize is adjusted upward to use up to max_memuse.
988 """
989 def decorator(f):
990 def wrapper(self):
Antoine Pitrou7cdb4952009-03-07 23:40:49 +0000991 # Retrieve values in case someone decided to adjust them
992 minsize = wrapper.minsize
993 memuse = wrapper.memuse
994 overhead = wrapper.overhead
Thomas Wouters477c8d52006-05-27 19:21:47 +0000995 if not max_memuse:
996 # If max_memuse is 0 (the default),
997 # we still want to run the tests with size set to a few kb,
998 # to make sure they work. We still want to avoid using
999 # too much memory, though, but we do that noisily.
1000 maxsize = 5147
Benjamin Peterson46d44402009-07-01 00:45:43 +00001001 self.assertFalse(maxsize * memuse + overhead > 20 * _1M)
Thomas Wouters477c8d52006-05-27 19:21:47 +00001002 else:
1003 maxsize = int((max_memuse - overhead) / memuse)
1004 if maxsize < minsize:
1005 # Really ought to print 'test skipped' or something
1006 if verbose:
1007 sys.stderr.write("Skipping %s because of memory "
1008 "constraint\n" % (f.__name__,))
1009 return
1010 # Try to keep some breathing room in memory use
1011 maxsize = max(maxsize - 50 * _1M, minsize)
1012 return f(self, maxsize)
1013 wrapper.minsize = minsize
1014 wrapper.memuse = memuse
1015 wrapper.overhead = overhead
1016 return wrapper
1017 return decorator
1018
Neal Norwitz3ce5d922008-08-24 07:08:55 +00001019def precisionbigmemtest(size, memuse, overhead=5*_1M):
1020 def decorator(f):
1021 def wrapper(self):
Antoine Pitrou7cdb4952009-03-07 23:40:49 +00001022 size = wrapper.size
1023 memuse = wrapper.memuse
1024 overhead = wrapper.overhead
Neal Norwitz3ce5d922008-08-24 07:08:55 +00001025 if not real_max_memuse:
1026 maxsize = 5147
1027 else:
1028 maxsize = size
1029
1030 if real_max_memuse and real_max_memuse < maxsize * memuse:
1031 if verbose:
1032 sys.stderr.write("Skipping %s because of memory "
1033 "constraint\n" % (f.__name__,))
1034 return
1035
1036 return f(self, maxsize)
1037 wrapper.size = size
1038 wrapper.memuse = memuse
1039 wrapper.overhead = overhead
1040 return wrapper
1041 return decorator
1042
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001043def bigaddrspacetest(f):
1044 """Decorator for tests that fill the address space."""
1045 def wrapper(self):
1046 if max_memuse < MAX_Py_ssize_t:
1047 if verbose:
1048 sys.stderr.write("Skipping %s because of memory "
1049 "constraint\n" % (f.__name__,))
1050 else:
1051 return f(self)
1052 return wrapper
1053
Thomas Wouters477c8d52006-05-27 19:21:47 +00001054#=======================================================================
Guido van Rossumd8faa362007-04-27 19:54:29 +00001055# unittest integration.
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001056
Steve Purcell5ddd1a82001-03-22 08:45:36 +00001057class BasicTestRunner:
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001058 def run(self, test):
Steve Purcell5ddd1a82001-03-22 08:45:36 +00001059 result = unittest.TestResult()
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001060 test(result)
1061 return result
1062
Benjamin Petersone549ead2009-03-28 21:42:05 +00001063def _id(obj):
1064 return obj
1065
1066def requires_resource(resource):
Antoine Pitrou5bc4fa72010-10-14 15:34:31 +00001067 if is_resource_enabled(resource):
Benjamin Petersone549ead2009-03-28 21:42:05 +00001068 return _id
1069 else:
1070 return unittest.skip("resource {0!r} is not enabled".format(resource))
1071
1072def cpython_only(test):
1073 """
1074 Decorator for tests only applicable on CPython.
1075 """
1076 return impl_detail(cpython=True)(test)
1077
1078def impl_detail(msg=None, **guards):
1079 if check_impl_detail(**guards):
1080 return _id
1081 if msg is None:
1082 guardnames, default = _parse_guards(guards)
1083 if default:
1084 msg = "implementation detail not available on {0}"
1085 else:
1086 msg = "implementation detail specific to {0}"
1087 guardnames = sorted(guardnames.keys())
1088 msg = msg.format(' or '.join(guardnames))
1089 return unittest.skip(msg)
1090
1091def _parse_guards(guards):
1092 # Returns a tuple ({platform_name: run_me}, default_value)
1093 if not guards:
1094 return ({'cpython': True}, False)
Eric Smith886b40a2009-04-26 21:26:45 +00001095 is_true = list(guards.values())[0]
1096 assert list(guards.values()) == [is_true] * len(guards) # all True or all False
Benjamin Petersone549ead2009-03-28 21:42:05 +00001097 return (guards, not is_true)
1098
1099# Use the following check to guard CPython's implementation-specific tests --
1100# or to run them only on the implementation(s) guarded by the arguments.
1101def check_impl_detail(**guards):
1102 """This function returns True or False depending on the host platform.
1103 Examples:
1104 if check_impl_detail(): # only on CPython (default)
1105 if check_impl_detail(jython=True): # only on Jython
1106 if check_impl_detail(cpython=False): # everywhere except on CPython
1107 """
1108 guards, default = _parse_guards(guards)
1109 return guards.get(platform.python_implementation().lower(), default)
1110
1111
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001112
Guido van Rossumd8faa362007-04-27 19:54:29 +00001113def _run_suite(suite):
Barry Warsawc88425e2001-09-20 06:31:22 +00001114 """Run tests from a unittest.TestSuite-derived class."""
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001115 if verbose:
Victor Stinnerf58087b2010-05-02 17:24:51 +00001116 runner = unittest.TextTestRunner(sys.stdout, verbosity=2)
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001117 else:
Steve Purcell5ddd1a82001-03-22 08:45:36 +00001118 runner = BasicTestRunner()
Fred Drakecd1b1dd2001-03-21 18:26:33 +00001119
Steve Purcell5ddd1a82001-03-22 08:45:36 +00001120 result = runner.run(suite)
1121 if not result.wasSuccessful():
Fred Drake14f6c182001-07-16 18:51:32 +00001122 if len(result.errors) == 1 and not result.failures:
1123 err = result.errors[0][1]
1124 elif len(result.failures) == 1 and not result.errors:
1125 err = result.failures[0][1]
1126 else:
R. David Murray723357e2009-10-19 18:06:17 +00001127 err = "multiple errors occurred"
1128 if not verbose: err += "; run in verbose mode for details"
Tim Peters2d84f2c2001-09-08 03:37:56 +00001129 raise TestFailed(err)
Tim Petersa0a62222001-09-09 06:12:01 +00001130
Barry Warsawc10d6902001-09-20 06:30:41 +00001131
Walter Dörwald21d3a322003-05-01 17:45:56 +00001132def run_unittest(*classes):
1133 """Run tests from unittest.TestCase-derived classes."""
Guido van Rossumd8faa362007-04-27 19:54:29 +00001134 valid_types = (unittest.TestSuite, unittest.TestCase)
Raymond Hettinger9dcbbea2003-04-27 07:54:23 +00001135 suite = unittest.TestSuite()
Walter Dörwald21d3a322003-05-01 17:45:56 +00001136 for cls in classes:
Guido van Rossum3172c5d2007-10-16 18:12:55 +00001137 if isinstance(cls, str):
Guido van Rossumd8faa362007-04-27 19:54:29 +00001138 if cls in sys.modules:
1139 suite.addTest(unittest.findTestCases(sys.modules[cls]))
1140 else:
1141 raise ValueError("str arguments must be keys in sys.modules")
1142 elif isinstance(cls, valid_types):
Raymond Hettinger21d99872003-07-16 02:59:32 +00001143 suite.addTest(cls)
1144 else:
1145 suite.addTest(unittest.makeSuite(cls))
Guido van Rossumd8faa362007-04-27 19:54:29 +00001146 _run_suite(suite)
Raymond Hettinger9dcbbea2003-04-27 07:54:23 +00001147
Barry Warsawc10d6902001-09-20 06:30:41 +00001148
Tim Petersa0a62222001-09-09 06:12:01 +00001149#=======================================================================
1150# doctest driver.
1151
1152def run_doctest(module, verbosity=None):
Tim Peters17111f32001-10-03 04:08:26 +00001153 """Run doctest on the given module. Return (#failures, #tests).
Tim Petersa0a62222001-09-09 06:12:01 +00001154
1155 If optional argument verbosity is not specified (or is None), pass
Benjamin Petersonee8712c2008-05-20 21:35:26 +00001156 support's belief about verbosity on to doctest. Else doctest's
Tim Petersbea3fb82001-09-10 01:39:21 +00001157 usual behavior is used (it searches sys.argv for -v).
Tim Petersa0a62222001-09-09 06:12:01 +00001158 """
1159
1160 import doctest
1161
1162 if verbosity is None:
1163 verbosity = verbose
1164 else:
1165 verbosity = None
1166
Tim Peters342ca752001-09-25 19:13:20 +00001167 # Direct doctest output (normally just errors) to real stdout; doctest
1168 # output shouldn't be compared by regrtest.
1169 save_stdout = sys.stdout
Tim Peters8dee8092001-09-25 20:05:11 +00001170 sys.stdout = get_original_stdout()
Tim Peters342ca752001-09-25 19:13:20 +00001171 try:
1172 f, t = doctest.testmod(module, verbose=verbosity)
1173 if f:
1174 raise TestFailed("%d of %d doctests failed" % (f, t))
1175 finally:
1176 sys.stdout = save_stdout
Raymond Hettinger35b34bd2003-05-17 00:58:33 +00001177 if verbose:
Georg Brandldb028442008-02-05 20:48:58 +00001178 print('doctest (%s) ... %d tests with zero failures' %
1179 (module.__name__, t))
Raymond Hettinger35b34bd2003-05-17 00:58:33 +00001180 return f, t
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001181
Antoine Pitrou060cee22009-11-13 16:29:04 +00001182
1183#=======================================================================
1184# Support for saving and restoring the imported modules.
1185
1186def modules_setup():
1187 return sys.modules.copy(),
1188
1189def modules_cleanup(oldmodules):
1190 # Encoders/decoders are registered permanently within the internal
1191 # codec cache. If we destroy the corresponding modules their
1192 # globals will be set to None which will trip up the cached functions.
1193 encodings = [(k, v) for k, v in sys.modules.items()
1194 if k.startswith('encodings.')]
1195 sys.modules.clear()
1196 sys.modules.update(encodings)
1197 sys.modules.update(oldmodules)
1198
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001199#=======================================================================
1200# Threading support to prevent reporting refleaks when running regrtest.py -R
1201
Antoine Pitrou65c9c642009-10-30 17:25:12 +00001202# NOTE: we use thread._count() rather than threading.enumerate() (or the
1203# moral equivalent thereof) because a threading.Thread object is still alive
1204# until its __bootstrap() method has returned, even after it has been
1205# unregistered from the threading module.
1206# thread._count(), on the other hand, only gets decremented *after* the
1207# __bootstrap() method has returned, which gives us reliable reference counts
1208# at the end of a test run.
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001209
Antoine Pitrou65c9c642009-10-30 17:25:12 +00001210def threading_setup():
Victor Stinner45df8202010-04-28 22:31:17 +00001211 if _thread:
1212 return _thread._count(),
1213 else:
1214 return 1,
Antoine Pitrou65c9c642009-10-30 17:25:12 +00001215
1216def threading_cleanup(nb_threads):
Victor Stinner45df8202010-04-28 22:31:17 +00001217 if not _thread:
1218 return
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001219 _MAX_COUNT = 10
Antoine Pitrou65c9c642009-10-30 17:25:12 +00001220 for count in range(_MAX_COUNT):
1221 n = _thread._count()
1222 if n == nb_threads:
1223 break
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001224 time.sleep(0.1)
Antoine Pitrou65c9c642009-10-30 17:25:12 +00001225 # XXX print a warning in case of failure?
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001226
Benjamin Petersonfa0d7032009-06-01 22:42:33 +00001227def reap_threads(func):
Victor Stinner45df8202010-04-28 22:31:17 +00001228 """Use this function when threads are being used. This will
1229 ensure that the threads are cleaned up even when the test fails.
1230 If threading is unavailable this function does nothing.
1231 """
1232 if not _thread:
1233 return func
1234
Benjamin Petersonfa0d7032009-06-01 22:42:33 +00001235 @functools.wraps(func)
1236 def decorator(*args):
1237 key = threading_setup()
1238 try:
1239 return func(*args)
1240 finally:
1241 threading_cleanup(*key)
1242 return decorator
1243
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001244def reap_children():
1245 """Use this function at the end of test_main() whenever sub-processes
1246 are started. This will help ensure that no extra children (zombies)
1247 stick around to hog resources and create problems when looking
1248 for refleaks.
1249 """
1250
1251 # Reap all our dead child processes so we don't leave zombies around.
1252 # These hog resources and might be causing some of the buildbots to die.
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001253 if hasattr(os, 'waitpid'):
1254 any_process = -1
1255 while True:
1256 try:
1257 # This will raise an exception on Windows. That's ok.
1258 pid, status = os.waitpid(any_process, os.WNOHANG)
1259 if pid == 0:
1260 break
1261 except:
1262 break
Collin Winterf2bf2b32010-03-17 00:41:56 +00001263
1264@contextlib.contextmanager
1265def swap_attr(obj, attr, new_val):
1266 """Temporary swap out an attribute with a new object.
1267
1268 Usage:
1269 with swap_attr(obj, "attr", 5):
1270 ...
1271
1272 This will set obj.attr to 5 for the duration of the with: block,
1273 restoring the old value at the end of the block. If `attr` doesn't
1274 exist on `obj`, it will be created and then deleted at the end of the
1275 block.
1276 """
1277 if hasattr(obj, attr):
1278 real_val = getattr(obj, attr)
1279 setattr(obj, attr, new_val)
1280 try:
1281 yield
1282 finally:
1283 setattr(obj, attr, real_val)
1284 else:
1285 setattr(obj, attr, new_val)
1286 try:
1287 yield
1288 finally:
1289 delattr(obj, attr)
1290
1291@contextlib.contextmanager
1292def swap_item(obj, item, new_val):
1293 """Temporary swap out an item with a new object.
1294
1295 Usage:
1296 with swap_item(obj, "item", 5):
1297 ...
1298
1299 This will set obj["item"] to 5 for the duration of the with: block,
1300 restoring the old value at the end of the block. If `item` doesn't
1301 exist on `obj`, it will be created and then deleted at the end of the
1302 block.
1303 """
1304 if item in obj:
1305 real_val = obj[item]
1306 obj[item] = new_val
1307 try:
1308 yield
1309 finally:
1310 obj[item] = real_val
1311 else:
1312 obj[item] = new_val
1313 try:
1314 yield
1315 finally:
1316 del obj[item]
Antoine Pitrou62f68ed2010-08-04 11:48:56 +00001317
1318def strip_python_stderr(stderr):
1319 """Strip the stderr of a Python process from potential debug output
1320 emitted by the interpreter.
1321
1322 This will typically be run on the result of the communicate() method
1323 of a subprocess.Popen object.
1324 """
1325 stderr = re.sub(br"\[\d+ refs\]\r?\n?$", b"", stderr).strip()
1326 return stderr
Antoine Pitrou1b03f2c2010-10-14 11:12:00 +00001327
1328def args_from_interpreter_flags():
1329 """Return a list of command-line arguments reproducing the current
1330 settings in sys.flags."""
1331 flag_opt_map = {
1332 'bytes_warning': 'b',
1333 'dont_write_bytecode': 'B',
1334 'ignore_environment': 'E',
1335 'no_user_site': 's',
1336 'no_site': 'S',
1337 'optimize': 'O',
1338 'verbose': 'v',
1339 }
1340 args = []
1341 for flag, opt in flag_opt_map.items():
1342 v = getattr(sys.flags, flag)
1343 if v > 0:
1344 args.append('-' + opt * v)
1345 return args