Spaces:
Build error
Build error
| import os | |
| import re | |
| import sys | |
| import shutil | |
| import warnings | |
| import textwrap | |
| import unittest | |
| import tempfile | |
| import subprocess | |
| #import distutils.core | |
| #from distutils import sysconfig | |
| from distutils import ccompiler | |
| import runtests | |
| import Cython.Distutils.extension | |
| import Cython.Distutils.old_build_ext as build_ext | |
| from Cython.Debugger import Cygdb as cygdb | |
| root = os.path.dirname(os.path.abspath(__file__)) | |
| codefile = os.path.join(root, 'codefile') | |
| cfuncs_file = os.path.join(root, 'cfuncs.c') | |
| with open(codefile) as f: | |
| source_to_lineno = dict((line.strip(), i + 1) for i, line in enumerate(f)) | |
| have_gdb = None | |
| def test_gdb(): | |
| global have_gdb | |
| if have_gdb is not None: | |
| return have_gdb | |
| have_gdb = False | |
| try: | |
| p = subprocess.Popen(['gdb', '-nx', '--version'], stdout=subprocess.PIPE) | |
| except OSError: | |
| # gdb not found | |
| gdb_version = None | |
| else: | |
| stdout, _ = p.communicate() | |
| # Based on Lib/test/test_gdb.py | |
| regex = r"GNU gdb [^\d]*(\d+)\.(\d+)" | |
| gdb_version = re.match(regex, stdout.decode('ascii', 'ignore')) | |
| if gdb_version: | |
| gdb_version_number = list(map(int, gdb_version.groups())) | |
| if gdb_version_number >= [7, 2]: | |
| have_gdb = True | |
| with tempfile.NamedTemporaryFile(mode='w+') as python_version_script: | |
| python_version_script.write( | |
| 'python import sys; print("%s %s" % sys.version_info[:2])') | |
| python_version_script.flush() | |
| p = subprocess.Popen(['gdb', '-batch', '-x', python_version_script.name], | |
| stdout=subprocess.PIPE) | |
| stdout, _ = p.communicate() | |
| try: | |
| internal_python_version = list(map(int, stdout.decode('ascii', 'ignore').split())) | |
| if internal_python_version < [2, 6]: | |
| have_gdb = False | |
| except ValueError: | |
| have_gdb = False | |
| if not have_gdb: | |
| warnings.warn('Skipping gdb tests, need gdb >= 7.2 with Python >= 2.6') | |
| return have_gdb | |
| class DebuggerTestCase(unittest.TestCase): | |
| def setUp(self): | |
| """ | |
| Run gdb and have cygdb import the debug information from the code | |
| defined in TestParseTreeTransforms's setUp method | |
| """ | |
| if not test_gdb(): | |
| return | |
| self.tempdir = tempfile.mkdtemp() | |
| self.destfile = os.path.join(self.tempdir, 'codefile.pyx') | |
| self.debug_dest = os.path.join(self.tempdir, | |
| 'cython_debug', | |
| 'cython_debug_info_codefile') | |
| self.cfuncs_destfile = os.path.join(self.tempdir, 'cfuncs') | |
| self.cwd = os.getcwd() | |
| try: | |
| os.chdir(self.tempdir) | |
| shutil.copy(codefile, self.destfile) | |
| shutil.copy(cfuncs_file, self.cfuncs_destfile + '.c') | |
| shutil.copy(cfuncs_file.replace('.c', '.h'), | |
| self.cfuncs_destfile + '.h') | |
| compiler = ccompiler.new_compiler() | |
| compiler.compile(['cfuncs.c'], debug=True, extra_postargs=['-fPIC']) | |
| opts = dict( | |
| test_directory=self.tempdir, | |
| module='codefile', | |
| ) | |
| optimization_disabler = build_ext.Optimization() | |
| cython_compile_testcase = runtests.CythonCompileTestCase( | |
| workdir=self.tempdir, | |
| # we clean up everything (not only compiled files) | |
| cleanup_workdir=False, | |
| tags=runtests.parse_tags(codefile), | |
| **opts | |
| ) | |
| new_stderr = open(os.devnull, 'w') | |
| stderr = sys.stderr | |
| sys.stderr = new_stderr | |
| optimization_disabler.disable_optimization() | |
| try: | |
| cython_compile_testcase.run_cython( | |
| targetdir=self.tempdir, | |
| incdir=None, | |
| annotate=False, | |
| extra_compile_options={ | |
| 'gdb_debug':True, | |
| 'output_dir':self.tempdir, | |
| }, | |
| **opts | |
| ) | |
| cython_compile_testcase.run_distutils( | |
| incdir=None, | |
| workdir=self.tempdir, | |
| extra_extension_args={'extra_objects':['cfuncs.o']}, | |
| **opts | |
| ) | |
| finally: | |
| optimization_disabler.restore_state() | |
| sys.stderr = stderr | |
| new_stderr.close() | |
| # ext = Cython.Distutils.extension.Extension( | |
| # 'codefile', | |
| # ['codefile.pyx'], | |
| # cython_gdb=True, | |
| # extra_objects=['cfuncs.o']) | |
| # | |
| # distutils.core.setup( | |
| # script_args=['build_ext', '--inplace'], | |
| # ext_modules=[ext], | |
| # cmdclass=dict(build_ext=Cython.Distutils.build_ext) | |
| # ) | |
| except: | |
| os.chdir(self.cwd) | |
| raise | |
| def tearDown(self): | |
| if not test_gdb(): | |
| return | |
| os.chdir(self.cwd) | |
| shutil.rmtree(self.tempdir) | |
| class GdbDebuggerTestCase(DebuggerTestCase): | |
| def setUp(self): | |
| if not test_gdb(): | |
| return | |
| super(GdbDebuggerTestCase, self).setUp() | |
| prefix_code = textwrap.dedent('''\ | |
| python | |
| import os | |
| import sys | |
| import traceback | |
| def excepthook(type, value, tb): | |
| traceback.print_exception(type, value, tb) | |
| sys.stderr.flush() | |
| sys.stdout.flush() | |
| os._exit(1) | |
| sys.excepthook = excepthook | |
| # Have tracebacks end up on sys.stderr (gdb replaces sys.stderr | |
| # with an object that calls gdb.write()) | |
| sys.stderr = sys.__stderr__ | |
| end | |
| ''') | |
| code = textwrap.dedent('''\ | |
| python | |
| from Cython.Debugger.Tests import test_libcython_in_gdb | |
| test_libcython_in_gdb.main(version=%r) | |
| end | |
| ''' % (sys.version_info[:2],)) | |
| self.gdb_command_file = cygdb.make_command_file(self.tempdir, | |
| prefix_code) | |
| with open(self.gdb_command_file, 'a') as f: | |
| f.write(code) | |
| args = ['gdb', '-batch', '-x', self.gdb_command_file, '-n', '--args', | |
| sys.executable, '-c', 'import codefile'] | |
| paths = [] | |
| path = os.environ.get('PYTHONPATH') | |
| if path: | |
| paths.append(path) | |
| paths.append(os.path.dirname(os.path.dirname( | |
| os.path.abspath(Cython.__file__)))) | |
| env = dict(os.environ, PYTHONPATH=os.pathsep.join(paths)) | |
| self.p = subprocess.Popen( | |
| args, | |
| stdout=subprocess.PIPE, | |
| stderr=subprocess.PIPE, | |
| env=env) | |
| def tearDown(self): | |
| if not test_gdb(): | |
| return | |
| try: | |
| super(GdbDebuggerTestCase, self).tearDown() | |
| if self.p: | |
| try: self.p.stdout.close() | |
| except: pass | |
| try: self.p.stderr.close() | |
| except: pass | |
| self.p.wait() | |
| finally: | |
| os.remove(self.gdb_command_file) | |
| class TestAll(GdbDebuggerTestCase): | |
| def test_all(self): | |
| if not test_gdb(): | |
| return | |
| out, err = self.p.communicate() | |
| out = out.decode('UTF-8') | |
| err = err.decode('UTF-8') | |
| exit_status = self.p.returncode | |
| if exit_status == 1: | |
| sys.stderr.write(out) | |
| sys.stderr.write(err) | |
| elif exit_status >= 2: | |
| border = u'*' * 30 | |
| start = u'%s v INSIDE GDB v %s' % (border, border) | |
| stderr = u'%s v STDERR v %s' % (border, border) | |
| end = u'%s ^ INSIDE GDB ^ %s' % (border, border) | |
| errmsg = u'\n%s\n%s%s\n%s%s' % (start, out, stderr, err, end) | |
| sys.stderr.write(errmsg) | |
| # FIXME: re-enable this to make the test fail on internal failures | |
| #self.assertEqual(exit_status, 0) | |
| if __name__ == '__main__': | |
| unittest.main() | |