diff options
Diffstat (limited to 'numpy/testing')
| -rw-r--r-- | numpy/testing/__init__.py | 4 | ||||
| -rw-r--r-- | numpy/testing/nosetester.py | 103 | ||||
| -rw-r--r-- | numpy/testing/numpytest.py | 538 | ||||
| -rw-r--r-- | numpy/testing/pkgtester.py | 14 | ||||
| -rw-r--r-- | numpy/testing/tests/test_utils.py | 2 |
5 files changed, 630 insertions, 31 deletions
diff --git a/numpy/testing/__init__.py b/numpy/testing/__init__.py index 17ca80c37..06e49cf2a 100644 --- a/numpy/testing/__init__.py +++ b/numpy/testing/__init__.py @@ -10,6 +10,8 @@ from unittest import TestCase import decorators as dec from utils import * +from parametric import ParametricTestCase from numpytest import * -from pkgtester import Tester +from nosetester import NoseTester as Tester +from nosetester import run_module_suite test = Tester().test diff --git a/numpy/testing/nosetester.py b/numpy/testing/nosetester.py index d35890446..3b98363ea 100644 --- a/numpy/testing/nosetester.py +++ b/numpy/testing/nosetester.py @@ -6,6 +6,7 @@ Implements test and bench functions for modules. import os import sys import re +import warnings def import_nose(): """ Import nose only when needed. @@ -27,6 +28,15 @@ def import_nose(): return nose +def run_module_suite(file_to_run = None): + if file_to_run is None: + f = sys._getframe(1) + file_to_run = f.f_locals.get('__file__', None) + assert file_to_run is not None + + import_nose().run(argv=['',file_to_run]) + + class NoseTester(object): """ Nose test runner. @@ -39,15 +49,10 @@ class NoseTester(object): >>> test = NoseTester().test - In practice, because nose may not be importable, the __init__ - files actually have: + This class is made available as numpy.testing.Tester: - >>> from scipy.testing.pkgtester import Tester + >>> from scipy.testing import Tester >>> test = Tester().test - - The pkgtester module checks for the presence of nose on the path, - returning this class if nose is present, and a null class - otherwise. """ def __init__(self, package=None): @@ -69,6 +74,26 @@ class NoseTester(object): package = os.path.dirname(package.__file__) self.package_path = package + # find the package name under test; this name is used to limit coverage + # reporting (if enabled) + pkg_temp = package + pkg_name = [] + while 'site-packages' in pkg_temp: + pkg_temp, p2 = os.path.split(pkg_temp) + if p2 == 'site-packages': + break + pkg_name.append(p2) + + # if package name determination failed, just default to numpy/scipy + if not pkg_name: + if 'scipy' in self.package_path: + self.package_name = 'scipy' + else: + self.package_name = 'numpy' + else: + pkg_name.reverse() + self.package_name = '.'.join(pkg_name) + def _add_doc(testtype): ''' Decorator to add docstring to functions using test labels @@ -123,22 +148,51 @@ class NoseTester(object): return argv @_add_doc('test') - def test(self, label='fast', verbose=1, extra_argv=None, doctests=False, - coverage=False): + def test(self, label='fast', verbose=1, extra_argv=None, doctests=False, + coverage=False, **kwargs): ''' Run tests for module using nose %(test_header)s doctests : boolean If True, run doctests in module, default False + coverage : boolean + If True, report coverage of NumPy code, default False + (Requires the coverage module: + http://nedbatchelder.com/code/modules/coverage.html) ''' - nose = import_nose() + old_args = set(['level', 'verbosity', 'all', 'sys_argv', 'testcase_pattern']) + unexpected_args = set(kwargs.keys()) - old_args + if len(unexpected_args) > 0: + ua = ', '.join(unexpected_args) + raise TypeError("test() got unexpected arguments: %s" % ua) + + # issue a deprecation warning if any of the pre-1.2 arguments to + # test are given + if old_args.intersection(kwargs.keys()): + warnings.warn("This method's signature will change in the next release; the level, verbosity, all, sys_argv, and testcase_pattern keyword arguments will be removed. Please update your code.", + DeprecationWarning, stacklevel=2) + + # Use old arguments if given (where it makes sense) + # For the moment, level and sys_argv are ignored + + # replace verbose with verbosity + if kwargs.get('verbosity') is not None: + verbose = kwargs.get('verbosity') + # cap verbosity at 3 because nose becomes *very* verbose beyond that + verbose = min(verbose, 3) + + # if all evaluates as True, omit attribute filter and run doctests + if kwargs.get('all'): + label = '' + doctests = True + argv = self._test_argv(label, verbose, extra_argv) if doctests: argv+=['--with-doctest','--doctest-tests'] if coverage: - argv+=['--cover-package=numpy','--with-coverage', - '--cover-tests','--cover-inclusive','--cover-erase'] + argv+=['--cover-package=%s' % self.package_name, '--with-coverage', + '--cover-tests', '--cover-inclusive', '--cover-erase'] # bypass these samples under distutils argv += ['--exclude','f2py_ext'] @@ -147,7 +201,28 @@ class NoseTester(object): argv += ['--exclude','pyrex_ext'] argv += ['--exclude','swig_ext'] - nose.run(argv=argv) + nose = import_nose() + + # Because nose currently discards the test result object, but we need to + # return it to the user, override TestProgram.runTests to retain the result + class NumpyTestProgram(nose.core.TestProgram): + def runTests(self): + """Run Tests. Returns true on success, false on failure, and sets + self.success to the same value. + """ + if self.testRunner is None: + self.testRunner = nose.core.TextTestRunner(stream=self.config.stream, + verbosity=self.config.verbosity, + config=self.config) + plug_runner = self.config.plugins.prepareTestRunner(self.testRunner) + if plug_runner is not None: + self.testRunner = plug_runner + self.result = self.testRunner.run(self.test) + self.success = self.result.wasSuccessful() + return self.success + + t = NumpyTestProgram(argv=argv, exit=False) + return t.result @_add_doc('benchmark') def bench(self, label='fast', verbose=1, extra_argv=None): @@ -157,4 +232,4 @@ class NoseTester(object): nose = import_nose() argv = self._test_argv(label, verbose, extra_argv) argv += ['--match', r'(?:^|[\\b_\\.%s-])[Bb]ench' % os.sep] - nose.run(argv=argv) + return nose.run(argv=argv) diff --git a/numpy/testing/numpytest.py b/numpy/testing/numpytest.py index 73002f92f..4daa3bf8e 100644 --- a/numpy/testing/numpytest.py +++ b/numpy/testing/numpytest.py @@ -10,7 +10,7 @@ import traceback import warnings __all__ = ['set_package_path', 'set_local_path', 'restore_path', - 'IgnoreException', 'importall',] + 'IgnoreException', 'NumpyTestCase', 'NumpyTest', 'importall',] DEBUG=0 from numpy.testing.utils import jiffies @@ -110,6 +110,93 @@ class _dummy_stream: self.stream.flush() +class NumpyTestCase (unittest.TestCase): + def __init__(self, *args, **kwds): + warnings.warn("NumpyTestCase will be removed in the next release; please update your code to use nose or unittest", + DeprecationWarning, stacklevel=2) + unittest.TestCase.__init__(self, *args, **kwds) + + def measure(self,code_str,times=1): + """ Return elapsed time for executing code_str in the + namespace of the caller for given times. + """ + frame = get_frame(1) + locs,globs = frame.f_locals,frame.f_globals + code = compile(code_str, + 'NumpyTestCase runner for '+self.__class__.__name__, + 'exec') + i = 0 + elapsed = jiffies() + while i<times: + i += 1 + exec code in globs,locs + elapsed = jiffies() - elapsed + return 0.01*elapsed + + def __call__(self, result=None): + if result is None or not hasattr(result, 'errors') \ + or not hasattr(result, 'stream'): + return unittest.TestCase.__call__(self, result) + + nof_errors = len(result.errors) + save_stream = result.stream + result.stream = _dummy_stream(save_stream) + unittest.TestCase.__call__(self, result) + if nof_errors != len(result.errors): + test, errstr = result.errors[-1][:2] + if isinstance(errstr, tuple): + errstr = str(errstr[0]) + elif isinstance(errstr, str): + errstr = errstr.split('\n')[-2] + else: + # allow for proxy classes + errstr = str(errstr).split('\n')[-2] + l = len(result.stream.data) + if errstr.startswith('IgnoreException:'): + if l==1: + assert result.stream.data[-1]=='E', \ + repr(result.stream.data) + result.stream.data[-1] = 'i' + else: + assert result.stream.data[-1]=='ERROR\n', \ + repr(result.stream.data) + result.stream.data[-1] = 'ignoring\n' + del result.errors[-1] + map(save_stream.write, result.stream.data) + save_stream.flush() + result.stream = save_stream + + def warn(self, message): + from numpy.distutils.misc_util import yellow_text + print>>sys.stderr,yellow_text('Warning: %s' % (message)) + sys.stderr.flush() + def info(self, message): + print>>sys.stdout, message + sys.stdout.flush() + + def rundocs(self, filename=None): + """ Run doc string tests found in filename. + """ + import doctest + if filename is None: + f = get_frame(1) + filename = f.f_globals['__file__'] + name = os.path.splitext(os.path.basename(filename))[0] + path = [os.path.dirname(filename)] + file, pathname, description = imp.find_module(name, path) + try: + m = imp.load_module(name, file, pathname, description) + finally: + file.close() + if sys.version[:3]<'2.4': + doctest.testmod(m, verbose=False) + else: + tests = doctest.DocTestFinder().find(m) + runner = doctest.DocTestRunner(verbose=False) + for test in tests: + runner.run(test) + return + def _get_all_method_names(cls): names = dir(cls) @@ -122,6 +209,455 @@ def _get_all_method_names(cls): # for debug build--check for memory leaks during the test. +class _NumPyTextTestResult(unittest._TextTestResult): + def startTest(self, test): + unittest._TextTestResult.startTest(self, test) + if self.showAll: + N = len(sys.getobjects(0)) + self._totnumobj = N + self._totrefcnt = sys.gettotalrefcount() + return + + def stopTest(self, test): + if self.showAll: + N = len(sys.getobjects(0)) + self.stream.write("objects: %d ===> %d; " % (self._totnumobj, N)) + self.stream.write("refcnts: %d ===> %d\n" % (self._totrefcnt, + sys.gettotalrefcount())) + return + +class NumPyTextTestRunner(unittest.TextTestRunner): + def _makeResult(self): + return _NumPyTextTestResult(self.stream, self.descriptions, self.verbosity) + + +class NumpyTest: + """ Numpy tests site manager. + + Usage: NumpyTest(<package>).test(level=1,verbosity=1) + + <package> is package name or its module object. + + Package is supposed to contain a directory tests/ with test_*.py + files where * refers to the names of submodules. See .rename() + method to redefine name mapping between test_*.py files and names of + submodules. Pattern test_*.py can be overwritten by redefining + .get_testfile() method. + + test_*.py files are supposed to define a classes, derived from + NumpyTestCase or unittest.TestCase, with methods having names + starting with test or bench or check. The names of TestCase classes + must have a prefix test. This can be overwritten by redefining + .check_testcase_name() method. + + And that is it! No need to implement test or test_suite functions + in each .py file. + + Old-style test_suite(level=1) hooks are also supported. + """ + _check_testcase_name = re.compile(r'test.*|Test.*').match + def check_testcase_name(self, name): + """ Return True if name matches TestCase class. + """ + return not not self._check_testcase_name(name) + + testfile_patterns = ['test_%(modulename)s.py'] + def get_testfile(self, module, verbosity = 0): + """ Return path to module test file. + """ + mstr = self._module_str + short_module_name = self._get_short_module_name(module) + d = os.path.split(module.__file__)[0] + test_dir = os.path.join(d,'tests') + local_test_dir = os.path.join(os.getcwd(),'tests') + if os.path.basename(os.path.dirname(local_test_dir)) \ + == os.path.basename(os.path.dirname(test_dir)): + test_dir = local_test_dir + for pat in self.testfile_patterns: + fn = os.path.join(test_dir, pat % {'modulename':short_module_name}) + if os.path.isfile(fn): + return fn + if verbosity>1: + self.warn('No test file found in %s for module %s' \ + % (test_dir, mstr(module))) + return + + def __init__(self, package=None): + warnings.warn("NumpyTest will be removed in the next release; please update your code to use nose or unittest", + DeprecationWarning, stacklevel=2) + if package is None: + from numpy.distutils.misc_util import get_frame + f = get_frame(1) + package = f.f_locals.get('__name__',f.f_globals.get('__name__',None)) + assert package is not None + self.package = package + self._rename_map = {} + + def rename(self, **kws): + """Apply renaming submodule test file test_<name>.py to + test_<newname>.py. + + Usage: self.rename(name='newname') before calling the + self.test() method. + + If 'newname' is None, then no tests will be executed for a given + module. + """ + for k,v in kws.items(): + self._rename_map[k] = v + return + + def _module_str(self, module): + filename = module.__file__[-30:] + if filename!=module.__file__: + filename = '...'+filename + return '<module %r from %r>' % (module.__name__, filename) + + def _get_method_names(self,clsobj,level): + names = [] + for mthname in _get_all_method_names(clsobj): + if mthname[:5] not in ['bench','check'] \ + and mthname[:4] not in ['test']: + continue + mth = getattr(clsobj, mthname) + if type(mth) is not types.MethodType: + continue + d = mth.im_func.func_defaults + if d is not None: + mthlevel = d[0] + else: + mthlevel = 1 + if level>=mthlevel: + if mthname not in names: + names.append(mthname) + for base in clsobj.__bases__: + for n in self._get_method_names(base,level): + if n not in names: + names.append(n) + return names + + def _get_short_module_name(self, module): + d,f = os.path.split(module.__file__) + short_module_name = os.path.splitext(os.path.basename(f))[0] + if short_module_name=='__init__': + short_module_name = module.__name__.split('.')[-1] + short_module_name = self._rename_map.get(short_module_name,short_module_name) + return short_module_name + + def _get_module_tests(self, module, level, verbosity): + mstr = self._module_str + + short_module_name = self._get_short_module_name(module) + if short_module_name is None: + return [] + + test_file = self.get_testfile(module, verbosity) + + if test_file is None: + return [] + + if not os.path.isfile(test_file): + if short_module_name[:5]=='info_' \ + and short_module_name[5:]==module.__name__.split('.')[-2]: + return [] + if short_module_name in ['__cvs_version__','__svn_version__']: + return [] + if short_module_name[-8:]=='_version' \ + and short_module_name[:-8]==module.__name__.split('.')[-2]: + return [] + if verbosity>1: + self.warn(test_file) + self.warn(' !! No test file %r found for %s' \ + % (os.path.basename(test_file), mstr(module))) + return [] + + if test_file in self.test_files: + return [] + + parent_module_name = '.'.join(module.__name__.split('.')[:-1]) + test_module_name,ext = os.path.splitext(os.path.basename(test_file)) + test_dir_module = parent_module_name+'.tests' + test_module_name = test_dir_module+'.'+test_module_name + + if test_dir_module not in sys.modules: + sys.modules[test_dir_module] = imp.new_module(test_dir_module) + + old_sys_path = sys.path[:] + try: + f = open(test_file,'r') + test_module = imp.load_module(test_module_name, f, + test_file, ('.py', 'r', 1)) + f.close() + except: + sys.path[:] = old_sys_path + self.warn('FAILURE importing tests for %s' % (mstr(module))) + output_exception(sys.stderr) + return [] + sys.path[:] = old_sys_path + + self.test_files.append(test_file) + + return self._get_suite_list(test_module, level, module.__name__) + + def _get_suite_list(self, test_module, level, module_name='__main__', + verbosity=1): + suite_list = [] + if hasattr(test_module, 'test_suite'): + suite_list.extend(test_module.test_suite(level)._tests) + for name in dir(test_module): + obj = getattr(test_module, name) + if type(obj) is not type(unittest.TestCase) \ + or not issubclass(obj, unittest.TestCase) \ + or not self.check_testcase_name(obj.__name__): + continue + for mthname in self._get_method_names(obj,level): + suite = obj(mthname) + if getattr(suite,'isrunnable',lambda mthname:1)(mthname): + suite_list.append(suite) + matched_suite_list = [suite for suite in suite_list \ + if self.testcase_match(suite.id()\ + .replace('__main__.',''))] + if verbosity>=0: + self.info(' Found %s/%s tests for %s' \ + % (len(matched_suite_list), len(suite_list), module_name)) + return matched_suite_list + + def _test_suite_from_modules(self, this_package, level, verbosity): + package_name = this_package.__name__ + modules = [] + for name, module in sys.modules.items(): + if not name.startswith(package_name) or module is None: + continue + if not hasattr(module,'__file__'): + continue + if os.path.basename(os.path.dirname(module.__file__))=='tests': + continue + modules.append((name, module)) + + modules.sort() + modules = [m[1] for m in modules] + + self.test_files = [] + suites = [] + for module in modules: + suites.extend(self._get_module_tests(module, abs(level), verbosity)) + + suites.extend(self._get_suite_list(sys.modules[package_name], + abs(level), verbosity=verbosity)) + return unittest.TestSuite(suites) + + def _test_suite_from_all_tests(self, this_package, level, verbosity): + importall(this_package) + package_name = this_package.__name__ + + # Find all tests/ directories under the package + test_dirs_names = {} + for name, module in sys.modules.items(): + if not name.startswith(package_name) or module is None: + continue + if not hasattr(module, '__file__'): + continue + d = os.path.dirname(module.__file__) + if os.path.basename(d)=='tests': + continue + d = os.path.join(d, 'tests') + if not os.path.isdir(d): + continue + if d in test_dirs_names: + continue + test_dir_module = '.'.join(name.split('.')[:-1]+['tests']) + test_dirs_names[d] = test_dir_module + + test_dirs = test_dirs_names.keys() + test_dirs.sort() + + # For each file in each tests/ directory with a test case in it, + # import the file, and add the test cases to our list + suite_list = [] + testcase_match = re.compile(r'\s*class\s+\w+\s*\(.*TestCase').match + for test_dir in test_dirs: + test_dir_module = test_dirs_names[test_dir] + + if test_dir_module not in sys.modules: + sys.modules[test_dir_module] = imp.new_module(test_dir_module) + + for fn in os.listdir(test_dir): + base, ext = os.path.splitext(fn) + if ext != '.py': + continue + f = os.path.join(test_dir, fn) + + # check that file contains TestCase class definitions: + fid = open(f, 'r') + skip = True + for line in fid: + if testcase_match(line): + skip = False + break + fid.close() + if skip: + continue + + # import the test file + n = test_dir_module + '.' + base + # in case test files import local modules + sys.path.insert(0, test_dir) + fo = None + try: + try: + fo = open(f) + test_module = imp.load_module(n, fo, f, + ('.py', 'U', 1)) + except Exception, msg: + print 'Failed importing %s: %s' % (f,msg) + continue + finally: + if fo: + fo.close() + del sys.path[0] + + suites = self._get_suite_list(test_module, level, + module_name=n, + verbosity=verbosity) + suite_list.extend(suites) + + all_tests = unittest.TestSuite(suite_list) + return all_tests + + def test(self, level=1, verbosity=1, all=True, sys_argv=[], + testcase_pattern='.*'): + """Run Numpy module test suite with level and verbosity. + + level: + None --- do nothing, return None + < 0 --- scan for tests of level=abs(level), + don't run them, return TestSuite-list + > 0 --- scan for tests of level, run them, + return TestRunner + > 10 --- run all tests (same as specifying all=True). + (backward compatibility). + + verbosity: + >= 0 --- show information messages + > 1 --- show warnings on missing tests + + all: + True --- run all test files (like self.testall()) + False (default) --- only run test files associated with a module + + sys_argv --- replacement of sys.argv[1:] during running + tests. + + testcase_pattern --- run only tests that match given pattern. + + It is assumed (when all=False) that package tests suite follows + the following convention: for each package module, there exists + file <packagepath>/tests/test_<modulename>.py that defines + TestCase classes (with names having prefix 'test_') with methods + (with names having prefixes 'check_' or 'bench_'); each of these + methods are called when running unit tests. + """ + if level is None: # Do nothing. + return + + if isinstance(self.package, str): + exec 'import %s as this_package' % (self.package) + else: + this_package = self.package + + self.testcase_match = re.compile(testcase_pattern).match + + if all: + all_tests = self._test_suite_from_all_tests(this_package, + level, verbosity) + else: + all_tests = self._test_suite_from_modules(this_package, + level, verbosity) + + if level < 0: + return all_tests + + runner = unittest.TextTestRunner(verbosity=verbosity) + old_sys_argv = sys.argv[1:] + sys.argv[1:] = sys_argv + # Use the builtin displayhook. If the tests are being run + # under IPython (for instance), any doctest test suites will + # fail otherwise. + old_displayhook = sys.displayhook + sys.displayhook = sys.__displayhook__ + try: + r = runner.run(all_tests) + finally: + sys.displayhook = old_displayhook + sys.argv[1:] = old_sys_argv + return r + + def testall(self, level=1,verbosity=1): + """ Run Numpy module test suite with level and verbosity. + + level: + None --- do nothing, return None + < 0 --- scan for tests of level=abs(level), + don't run them, return TestSuite-list + > 0 --- scan for tests of level, run them, + return TestRunner + + verbosity: + >= 0 --- show information messages + > 1 --- show warnings on missing tests + + Different from .test(..) method, this method looks for + TestCase classes from all files in <packagedir>/tests/ + directory and no assumptions are made for naming the + TestCase classes or their methods. + """ + return self.test(level=level, verbosity=verbosity, all=True) + + def run(self): + """ Run Numpy module test suite with level and verbosity + taken from sys.argv. Requires optparse module. + """ + try: + from optparse import OptionParser + except ImportError: + self.warn('Failed to import optparse module, ignoring.') + return self.test() + usage = r'usage: %prog [-v <verbosity>] [-l <level>]'\ + r' [-s "<replacement of sys.argv[1:]>"]'\ + r' [-t "<testcase pattern>"]' + parser = OptionParser(usage) + parser.add_option("-v", "--verbosity", + action="store", + dest="verbosity", + default=1, + type='int') + parser.add_option("-l", "--level", + action="store", + dest="level", + default=1, + type='int') + parser.add_option("-s", "--sys-argv", + action="store", + dest="sys_argv", + default='', + type='string') + parser.add_option("-t", "--testcase-pattern", + action="store", + dest="testcase_pattern", + default=r'.*', + type='string') + (options, args) = parser.parse_args() + return self.test(options.level,options.verbosity, + sys_argv=shlex.split(options.sys_argv or ''), + testcase_pattern=options.testcase_pattern) + + def warn(self, message): + from numpy.distutils.misc_util import yellow_text + print>>sys.stderr,yellow_text('Warning: %s' % (message)) + sys.stderr.flush() + def info(self, message): + print>>sys.stdout, message + sys.stdout.flush() def importall(package): """ diff --git a/numpy/testing/pkgtester.py b/numpy/testing/pkgtester.py deleted file mode 100644 index 51e8d62c4..000000000 --- a/numpy/testing/pkgtester.py +++ /dev/null @@ -1,14 +0,0 @@ -''' Define test function for scipy package - -Module tests for presence of useful version of nose. If present -returns NoseTester, otherwise returns a placeholder test routine -reporting lack of nose and inability to run tests. Typical use is in -module __init__: - -from scipy.testing.pkgtester import Tester -test = Tester().test - -See nosetester module for test implementation - -''' -from numpy.testing.nosetester import NoseTester as Tester diff --git a/numpy/testing/tests/test_utils.py b/numpy/testing/tests/test_utils.py index 27cc4a809..ea8fa044b 100644 --- a/numpy/testing/tests/test_utils.py +++ b/numpy/testing/tests/test_utils.py @@ -163,4 +163,4 @@ class TestRaises(unittest.TestCase): if __name__ == '__main__': - nose.run(argv=['', __file__]) + run_module_suite() |