"""Supporting definitions for the Python regression tests."""
if __name__
!= 'test.test_support':
raise ImportError, 'test_support must be imported from the test package'
"""Base class for regression test exceptions."""
class TestSkipped(Error
):
This can be raised to indicate that a test was deliberatly
skipped, but not because a feature wasn't available. For
example, if some resource can't be used, such as the network
appears to be unavailable, this should be raised instead of
class ResourceDenied(TestSkipped
):
"""Test skipped because it requested a disallowed resource.
This is raised when a test calls requires() for a resource that
has not be enabled. It is used to distinguish between expected
verbose
= 1 # Flag set to 0 by regrtest.py
use_resources
= None # Flag set to [] by regrtest.py
# _original_stdout is meant to hold stdout at the time regrtest began.
# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
# The point is to have some flavor of stdout the user can actually see.
def record_original_stdout(stdout
):
_original_stdout
= stdout
def get_original_stdout():
return _original_stdout
or sys
.stdout
'''"Forget" a module was ever imported by removing it from sys.modules and
deleting any .pyc and .pyo files.'''
os
.unlink(os
.path
.join(dirname
, modname
+ os
.extsep
+ 'pyc'))
# Deleting the .pyo file cannot be within the 'try' for the .pyc since
# the chance exists that there is no .pyc (and thus the 'try' statement
# is exited) but there is a .pyo file.
os
.unlink(os
.path
.join(dirname
, modname
+ os
.extsep
+ 'pyo'))
def is_resource_enabled(resource
):
"""Test whether a resource is enabled. Known resources are set by
return use_resources
is not None and resource
in use_resources
def requires(resource
, msg
=None):
"""Raise ResourceDenied if the specified resource is not available.
If the caller's module is __main__ then automatically return True. The
possibility of False being returned occurs when regrtest.py is executing."""
# see if the caller's module is __main__ - if so, treat as if
if sys
._getframe
().f_back
.f_globals
.get("__name__") == "__main__":
if not is_resource_enabled(resource
):
msg
= "Use of the `%s' resource not enabled" % resource
raise ResourceDenied(msg
)
def fcmp(x
, y
): # fuzzy comparison function
if type(x
) == type(0.0) or type(y
) == type(0.0):
fuzz
= (abs(x
) + abs(y
)) * FUZZ
elif type(x
) == type(y
) and type(x
) in (type(()), type([])):
for i
in range(min(len(x
), len(y
))):
outcome
= fcmp(x
[i
], y
[i
])
return cmp(len(x
), len(y
))
is_jython
= sys
.platform
.startswith('java')
# Filename used for testing
# Jython disallows @ in module names
elif os
.name
== 'riscos':
# Unicode name only used if TEST_FN_ENCODING exists for the platform.
# Assuming sys.getfilesystemencoding()!=sys.getdefaultencoding()
# TESTFN_UNICODE is a filename that can be encoded using the
# file system encoding, but *not* with the default (ascii) encoding
if isinstance('', unicode):
# XXX perhaps unicode() should accept Unicode strings?
TESTFN_UNICODE
= "@test-\xe0\xf2"
TESTFN_UNICODE
= unicode("@test-\xe0\xf2", "latin-1")
TESTFN_ENCODING
= sys
.getfilesystemencoding()
# TESTFN_UNICODE_UNENCODEABLE is a filename that should *not* be
# able to be encoded by *either* the default or filesystem encoding.
# This test really only makes sense on Windows NT platforms
# which have special Unicode support in posixmodule.
if (not hasattr(sys
, "getwindowsversion") or
sys
.getwindowsversion()[3] < 2): # 0=win32s or 1=9x/ME
TESTFN_UNICODE_UNENCODEABLE
= None
# Japanese characters (I think - from bug 846133)
TESTFN_UNICODE_UNENCODEABLE
= eval('u"@test-\u5171\u6709\u3055\u308c\u308b"')
# XXX - Note - should be using TESTFN_ENCODING here - but for
# Windows, "mbcs" currently always operates as if in
# errors=ignore' mode - hence we get '?' characters rather than
# the exception. 'Latin1' operates as we expect - ie, fails.
# See [ 850997 ] mbcs encoding ignores errors
TESTFN_UNICODE_UNENCODEABLE
.encode("Latin1")
except UnicodeEncodeError:
'WARNING: The filename %r CAN be encoded by the filesystem. ' \
'Unicode filename tests may not be effective' \
% TESTFN_UNICODE_UNENCODEABLE
# Make sure we can write to TESTFN, try in /tmp if we can't
TMP_TESTFN
= os
.path
.join('/tmp', TESTFN
)
fp
= open(TMP_TESTFN
, 'w+')
print ('WARNING: tests will fail, unable to write to: %s or %s' %
def findfile(file, here
=__file__
):
"""Try to find a file on sys.path and the working directory. If it is not
found the argument passed to the function is returned (this does not
necessarily signal failure; could still be the legitimate path)."""
path
= [os
.path
.dirname(here
)] + path
fn
= os
.path
.join(dn
, file)
if os
.path
.exists(fn
): return fn
def verify(condition
, reason
='test failed'):
"""Verify that condition is true. If not, raise TestFailed.
The optional argument reason can be given to provide
"""Raise TestFailed if a == b is false.
This is better than verify(a == b) because, in case of failure, the
error message incorporates repr(a) and repr(b) so you can see the
Note that "not (a == b)" isn't necessarily the same as "a != b"; the
raise TestFailed
, "%r == %r" % (a
, b
)
"Like repr(dict), but in sorted order."
reprpairs
= ["%r: %r" % pair
for pair
in items
]
withcommas
= ", ".join(reprpairs
)
return "{%s}" % withcommas
def check_syntax(statement
):
compile(statement
, '<string>', 'exec')
print 'Missing SyntaxError: "%s"' % statement
#=======================================================================
# Preliminary PyUNIT integration.
result
= unittest
.TestResult()
def run_suite(suite
, testclass
=None):
"""Run tests from a unittest.TestSuite-derived class."""
runner
= unittest
.TextTestRunner(sys
.stdout
, verbosity
=2)
runner
= BasicTestRunner()
result
= runner
.run(suite
)
if not result
.wasSuccessful():
if len(result
.errors
) == 1 and not result
.failures
:
err
= result
.errors
[0][1]
elif len(result
.failures
) == 1 and not result
.errors
:
err
= result
.failures
[0][1]
msg
= "errors occurred; run in verbose mode for details"
msg
= "errors occurred in %s.%s" \
% (testclass
.__module
__, testclass
.__name
__)
def run_unittest(*classes
):
"""Run tests from unittest.TestCase-derived classes."""
suite
= unittest
.TestSuite()
if isinstance(cls
, (unittest
.TestSuite
, unittest
.TestCase
)):
suite
.addTest(unittest
.makeSuite(cls
))
run_suite(suite
, testclass
)
#=======================================================================
def run_doctest(module
, verbosity
=None):
"""Run doctest on the given module. Return (#failures, #tests).
If optional argument verbosity is not specified (or is None), pass
test_support's belief about verbosity on to doctest. Else doctest's
usual behavior is used (it searches sys.argv for -v).
# Direct doctest output (normally just errors) to real stdout; doctest
# output shouldn't be compared by regrtest.
sys
.stdout
= get_original_stdout()
f
, t
= doctest
.testmod(module
, verbose
=verbosity
)
raise TestFailed("%d of %d doctests failed" % (f
, t
))
print 'doctest (%s) ... %d tests with zero failures' % (module
.__name
__, t
)