Adding cython v0.20.2 in third-party.

third_party/cython/src/Cython/Debugger/Tests/TestLibCython.py

+
+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.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')
+
+f = open(codefile)
+try:
+    source_to_lineno = dict([ (line.strip(), i + 1) for i, line in enumerate(f) ])
+finally:
+    f.close()
+
+# Cython.Distutils.__init__ imports build_ext from build_ext which means we
+# can't access the module anymore. Get it from sys.modules instead.
+build_ext = sys.modules['Cython.Distutils.build_ext']
+
+
+have_gdb = None
+def test_gdb():
+    global have_gdb
+    if have_gdb is not None:
+        return have_gdb
+
+    try:
+        p = subprocess.Popen(['gdb', '-v'], stdout=subprocess.PIPE)
+        have_gdb = True
+    except OSError:
+        # gdb was not installed
+        have_gdb = False
+    else:
+        gdb_version = p.stdout.read().decode('ascii', 'ignore')
+        p.wait()
+        p.stdout.close()
+
+    if have_gdb:
+        # Based on Lib/test/test_gdb.py
+        regex = "^GNU gdb [^\d]*(\d+)\.(\d+)"
+        gdb_version_number = list(map(int, re.search(regex, gdb_version).groups()))
+
+        if gdb_version_number >= [7, 2]:
+            python_version_script = tempfile.NamedTemporaryFile(mode='w+')
+            try:
+                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)
+                try:
+                    python_version = p.stdout.read().decode('ascii')
+                    p.wait()
+                finally:
+                    p.stdout.close()
+                try:
+                    python_version_number = list(map(int, python_version.split()))
+                except ValueError:
+                    have_gdb = False
+            finally:
+                python_version_script.close()
+
+    # Be Python 3 compatible
+    if (not have_gdb
+        or gdb_version_number < [7, 2]
+        or python_version_number < [2, 6]):
+        warnings.warn(
+            'Skipping gdb tests, need gdb >= 7.2 with Python >= 2.6')
+        have_gdb = False
+
+    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')
+
+            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)
+                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)
+
+        f = open(self.gdb_command_file, 'a')
+        try:
+            f.write(code)
+        finally:
+            f.close()
+
+        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=open(os.devnull, 'w'),
+            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()
+        err = err.decode('UTF-8')
+
+        exit_status = self.p.returncode
+
+        if exit_status == 1:
+            sys.stderr.write(err)
+        elif exit_status >= 2:
+            border = u'*' * 30
+            start  = u'%s   v INSIDE GDB v   %s' % (border, border)
+            end    = u'%s   ^ INSIDE GDB ^   %s' % (border, border)
+            errmsg = u'\n%s\n%s%s' % (start, err, end)
+
+            sys.stderr.write(errmsg)
+
+
+if __name__ == '__main__':
+    unittest.main()