distutils_distro.parse_config_files(cfgfiles)
EXT_DEP_MODULES = {
- 'numpy' : 'tag:numpy',
- 'pstats' : 'tag:pstats',
- 'posix' : 'tag:posix',
+ 'tag:numpy' : 'numpy',
+ 'tag:pstats': 'pstats',
+ 'tag:posix' : 'posix',
}
-def get_numpy_include_dirs():
+def update_numpy_extension(ext):
import numpy
- return [numpy.get_include()]
+ ext.include_dirs.append(numpy.get_include())
-# TODO: use tags
-EXT_DEP_INCLUDES = [
- # test name matcher , callable returning list
- (re.compile('numpy_.*').match, get_numpy_include_dirs),
-]
+EXT_EXTRAS = {
+ 'tag:numpy' : update_numpy_extension,
+}
# TODO: use tags
VER_DEP_MODULES = {
]),
(2,6) : (operator.lt, lambda x: x in ['run.print_function',
'run.cython3',
+ 'run.generators_py', # generators, with statement
'run.pure_py', # decorators, with statement
]),
+ (2,7) : (operator.lt, lambda x: x in ['run.withstat_py', # multi context with statement
+ ]),
# The next line should start (3,); but this is a dictionary, so
# we can only have one (3,) key. Since 2.7 is supposed to be the
# last 2.x release, things would have to change drastically for this
# to be unsafe...
- (2,999): (operator.lt, lambda x: x in ['run.special_methods_T561_py3']),
+ (2,999): (operator.lt, lambda x: x in ['run.special_methods_T561_py3',
+ 'run.test_raisefrom',
+ ]),
(3,): (operator.ge, lambda x: x in ['run.non_future_division',
'compile.extsetslice',
'compile.extdelslice',
parse_tags = memoize(parse_tags)
+list_unchanging_dir = memoize(lambda x: os.listdir(x))
+
class build_ext(_build_ext):
def build_extension(self, ext):
os.makedirs(workdir)
suite = unittest.TestSuite()
- filenames = os.listdir(path)
+ filenames = list_unchanging_dir(path)
filenames.sort()
for filename in filenames:
filepath = os.path.join(path, filename)
return suite
def build_tests(self, test_class, path, workdir, module, expect_errors, tags):
- if 'werror' in tags['tags']:
+ if 'werror' in tags['tag']:
warning_errors = True
else:
warning_errors = False
def setUp(self):
from Cython.Compiler import Options
+ self._saved_options = [ (name, getattr(Options, name))
+ for name in ('warning_errors', 'error_on_unknown_names') ]
Options.warning_errors = self.warning_errors
if self.workdir not in sys.path:
def tearDown(self):
from Cython.Compiler import Options
- Options.warning_errors = False
+ for name, value in self._saved_options:
+ setattr(Options, name, value)
try:
sys.path.remove(self.workdir)
def build_target_filename(self, module_name):
target = '%s.%s' % (module_name, self.language)
return target
-
- def copy_related_files(self, test_directory, target_directory, module_name):
+
+ def related_files(self, test_directory, module_name):
is_related = re.compile('%s_.*[.].*' % module_name).match
- for filename in os.listdir(test_directory):
- if is_related(filename):
- shutil.copy(os.path.join(test_directory, filename),
- target_directory)
+ return [filename for filename in list_unchanging_dir(test_directory)
+ if is_related(filename)]
- def find_source_files(self, workdir, module_name):
- is_related = re.compile('%s_.*[.]%s' % (module_name, self.language)).match
- return [self.build_target_filename(module_name)] + [
- filename for filename in os.listdir(workdir)
- if is_related(filename) and os.path.isfile(os.path.join(workdir, filename)) ]
+ def copy_files(self, test_directory, target_directory, file_list):
+ for filename in file_list:
+ shutil.copy(os.path.join(test_directory, filename),
+ target_directory)
+
+ def source_files(self, workdir, module_name, file_list):
+ return ([self.build_target_filename(module_name)] +
+ [filename for filename in file_list
+ if not os.path.isfile(os.path.join(workdir, filename))])
def split_source_and_output(self, test_directory, module, workdir):
source_file = self.find_module_source_file(os.path.join(test_directory, module) + '.pyx')
def run_distutils(self, test_directory, module, workdir, incdir,
extra_extension_args=None):
+ original_source = self.find_module_source_file(
+ os.path.join(test_directory, module + '.pyx'))
+ try:
+ tags = parse_tags(original_source)
+ except IOError:
+ tags = {}
cwd = os.getcwd()
os.chdir(workdir)
try:
build_extension.finalize_options()
if COMPILER:
build_extension.compiler = COMPILER
- ext_include_dirs = []
- for match, get_additional_include_dirs in EXT_DEP_INCLUDES:
- if match(module):
- ext_include_dirs += get_additional_include_dirs()
ext_compile_flags = CFLAGS[:]
if build_extension.compiler == 'mingw32':
ext_compile_flags.append('-Wno-format')
if extra_extension_args is None:
extra_extension_args = {}
- self.copy_related_files(test_directory, workdir, module)
+ related_files = self.related_files(test_directory, module)
+ self.copy_files(test_directory, workdir, related_files)
extension = Extension(
module,
- sources = self.find_source_files(workdir, module),
- include_dirs = ext_include_dirs,
+ sources = self.source_files(workdir, module, related_files),
extra_compile_args = ext_compile_flags,
**extra_extension_args
)
+ for matcher, fixer in EXT_EXTRAS.items():
+ if isinstance(matcher, str):
+ del EXT_EXTRAS[matcher]
+ matcher = string_selector(matcher)
+ EXT_EXTRAS[matcher] = fixer
+ if matcher(module, tags):
+ extension = fixer(extension) or extension
if self.language == 'cpp':
extension.language = 'c++'
build_extension.extensions = [extension]
self.run_doctests(self.module, result)
def run_doctests(self, module_name, result):
- if sys.version_info[0] >= 3 or not hasattr(os, 'fork') or not self.fork:
- doctest.DocTestSuite(module_name).run(result)
- gc.collect()
- return
-
- # fork to make sure we do not keep the tested module loaded
- result_handle, result_file = tempfile.mkstemp()
- os.close(result_handle)
- child_id = os.fork()
- if not child_id:
- result_code = 0
- try:
- try:
- tests = None
- try:
- partial_result = PartialTestResult(result)
- tests = doctest.DocTestSuite(module_name)
- tests.run(partial_result)
- gc.collect()
- except Exception:
- if tests is None:
- # importing failed, try to fake a test class
- tests = _FakeClass(
- failureException=sys.exc_info()[1],
- _shortDescription=self.shortDescription(),
- module_name=None)
- partial_result.addError(tests, sys.exc_info())
- result_code = 1
- output = open(result_file, 'wb')
- pickle.dump(partial_result.data(), output)
- except:
- traceback.print_exc()
- finally:
- try: output.close()
- except: pass
- os._exit(result_code)
+ def run_test(result):
+ tests = doctest.DocTestSuite(module_name)
+ tests.run(result)
+ run_forked_test(result, run_test, self.shortDescription(), self.fork)
+
+
+def run_forked_test(result, run_func, test_name, fork=True):
+ if not fork or sys.version_info[0] >= 3 or not hasattr(os, 'fork'):
+ run_func(result)
+ gc.collect()
+ return
+ # fork to make sure we do not keep the tested module loaded
+ result_handle, result_file = tempfile.mkstemp()
+ os.close(result_handle)
+ child_id = os.fork()
+ if not child_id:
+ result_code = 0
try:
- cid, result_code = os.waitpid(child_id, 0)
- # os.waitpid returns the child's result code in the
- # upper byte of result_code, and the signal it was
- # killed by in the lower byte
- if result_code & 255:
- raise Exception("Tests in module '%s' were unexpectedly killed by signal %d"%
- (module_name, result_code & 255))
- result_code = result_code >> 8
- if result_code in (0,1):
- input = open(result_file, 'rb')
+ try:
+ tests = None
try:
- PartialTestResult.join_results(result, pickle.load(input))
- finally:
- input.close()
- if result_code:
- raise Exception("Tests in module '%s' exited with status %d" %
- (module_name, result_code))
+ partial_result = PartialTestResult(result)
+ run_func(partial_result)
+ gc.collect()
+ except Exception:
+ if tests is None:
+ # importing failed, try to fake a test class
+ tests = _FakeClass(
+ failureException=sys.exc_info()[1],
+ _shortDescription=test_name,
+ module_name=None)
+ partial_result.addError(tests, sys.exc_info())
+ result_code = 1
+ output = open(result_file, 'wb')
+ pickle.dump(partial_result.data(), output)
+ except:
+ traceback.print_exc()
finally:
- try: os.unlink(result_file)
+ try: output.close()
except: pass
+ os._exit(result_code)
+
+ try:
+ cid, result_code = os.waitpid(child_id, 0)
+ # os.waitpid returns the child's result code in the
+ # upper byte of result_code, and the signal it was
+ # killed by in the lower byte
+ if result_code & 255:
+ raise Exception("Tests in module '%s' were unexpectedly killed by signal %d"%
+ (module_name, result_code & 255))
+ result_code = result_code >> 8
+ if result_code in (0,1):
+ input = open(result_file, 'rb')
+ try:
+ PartialTestResult.join_results(result, pickle.load(input))
+ finally:
+ input.close()
+ if result_code:
+ raise Exception("Tests in module '%s' exited with status %d" %
+ (module_name, result_code))
+ finally:
+ try: os.unlink(result_file)
+ except: pass
class PureDoctestTestCase(unittest.TestCase):
def __init__(self, module_name, module_path):
class CythonPyregrTestCase(CythonRunTestCase):
+ def setUp(self):
+ CythonRunTestCase.setUp(self)
+ from Cython.Compiler import Options
+ Options.error_on_unknown_names = False
+
def _run_unittest(self, result, *classes):
"""Run tests from unittest.TestCase-derived classes."""
valid_types = (unittest.TestSuite, unittest.TestCase)
except ImportError: # Py3k
from test import support
- def run_unittest(*classes):
- return self._run_unittest(result, *classes)
- def run_doctest(module, verbosity=None):
- return self._run_doctest(result, module)
+ def run_test(result):
+ def run_unittest(*classes):
+ return self._run_unittest(result, *classes)
+ def run_doctest(module, verbosity=None):
+ return self._run_doctest(result, module)
- support.run_unittest = run_unittest
- support.run_doctest = run_doctest
+ support.run_unittest = run_unittest
+ support.run_doctest = run_doctest
- try:
- module = __import__(self.module)
- if hasattr(module, 'test_main'):
- module.test_main()
- except (unittest.SkipTest, support.ResourceDenied):
- result.addSkip(self, 'ok')
+ try:
+ module = __import__(self.module)
+ if hasattr(module, 'test_main'):
+ module.test_main()
+ except (unittest.SkipTest, support.ResourceDenied):
+ result.addSkip(self, 'ok')
+
+ run_forked_test(result, run_test, self.shortDescription(), self.fork)
include_debugger = sys.version_info[:2] > (2, 5)
class MissingDependencyExcluder:
def __init__(self, deps):
- # deps: { module name : matcher func }
+ # deps: { matcher func : module name }
self.exclude_matchers = []
- for mod, matcher in deps.items():
+ for matcher, mod in deps.items():
try:
__import__(mod)
except ImportError:
parser.add_option("--coverage-xml", dest="coverage_xml",
action="store_true", default=False,
help="collect source coverage data for the Compiler in XML format")
+ parser.add_option("--coverage-html", dest="coverage_html",
+ action="store_true", default=False,
+ help="collect source coverage data for the Compiler in HTML format")
parser.add_option("-A", "--annotate", dest="annotate_source",
action="store_true", default=True,
help="generate annotated HTML versions of the test source files")
WITH_CYTHON = options.with_cython
- if options.coverage or options.coverage_xml:
+ if options.coverage or options.coverage_xml or options.coverage_html:
if not WITH_CYTHON:
- options.coverage = options.coverage_xml = False
+ options.coverage = options.coverage_xml = options.coverage_html = False
else:
from coverage import coverage as _coverage
coverage = _coverage(branch=True)
test_suite.addTest(filetests.build_suite())
if options.system_pyregr and languages:
- filetests = TestBuilder(ROOTDIR, WORKDIR, selectors, exclude_selectors,
- options.annotate_source, options.cleanup_workdir,
- options.cleanup_sharedlibs, True,
- options.cython_only, languages, test_bugs,
- options.fork, options.language_level)
- test_suite.addTest(
- filetests.handle_directory(
- os.path.join(sys.prefix, 'lib', 'python'+sys.version[:3], 'test'),
- 'pyregr'))
+ sys_pyregr_dir = os.path.join(sys.prefix, 'lib', 'python'+sys.version[:3], 'test')
+ if os.path.isdir(sys_pyregr_dir):
+ filetests = TestBuilder(ROOTDIR, WORKDIR, selectors, exclude_selectors,
+ options.annotate_source, options.cleanup_workdir,
+ options.cleanup_sharedlibs, True,
+ options.cython_only, languages, test_bugs,
+ options.fork, sys.version_info[0])
+ sys.stderr.write("Including CPython regression tests in %s\n" % sys_pyregr_dir)
+ test_suite.addTest(filetests.handle_directory(sys_pyregr_dir, 'pyregr'))
if options.xml_output_dir:
from Cython.Tests.xmlrunner import XMLTestRunner
result = test_runner.run(test_suite)
- if options.coverage or options.coverage_xml:
+ if options.coverage or options.coverage_xml or options.coverage_html:
coverage.stop()
ignored_modules = ('Options', 'Version', 'DebugFlags', 'CmdLine')
modules = [ module for name, module in sys.modules.items()
coverage.report(modules, show_missing=0)
if options.coverage_xml:
coverage.xml_report(modules, outfile="coverage-report.xml")
+ if options.coverage_html:
+ coverage.html_report(modules, directory="coverage-report-html")
if missing_dep_excluder.tests_missing_deps:
sys.stderr.write("Following tests excluded because of missing dependencies on your system:\n")