merge

Cython/Debugger/Tests/TestLibCython.py

@@ -45,7 +45,7 @@ class DebuggerTestCase(unittest.TestCase):
         shutil.copy(cfuncs_file, self.cfuncs_destfile + '.c')
         
         compiler = ccompiler.new_compiler()
-        compiler.compile(['cfuncs.c'], debug=True)
+        compiler.compile(['cfuncs.c'], debug=True, extra_postargs=['-fPIC'])
         
         opts = dict(
             test_directory=self.tempdir,
@@ -122,14 +122,16 @@ class GdbDebuggerTestCase(DebuggerTestCase):
             python
             
             from Cython.Debugger.Tests import test_libcython_in_gdb
-            test_libcython_in_gdb.main()
+            test_libcython_in_gdb.main(version=%r)
             
             end
-            ''')
+            ''' % (sys.version_info[:2],))
         
         self.gdb_command_file = cygdb.make_command_file(self.tempdir, 
                                                         prefix_code)
-        open(self.gdb_command_file, 'a').write(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']
@@ -149,7 +151,7 @@ class GdbDebuggerTestCase(DebuggerTestCase):
             # gdb was not installed
             have_gdb = False
         else:
-            gdb_version = p.stdout.read()
+            gdb_version = p.stdout.read().decode('ascii')
             p.wait()
             p.stdout.close()
         
@@ -158,7 +160,8 @@ class GdbDebuggerTestCase(DebuggerTestCase):
             regex = "^GNU gdb [^\d]*(\d+)\.(\d+)"
             gdb_version_number = re.search(regex, gdb_version).groups()
 
-        if not have_gdb or map(int, gdb_version_number) < [7, 2]:
+        # Be Python 3 compatible
+        if not have_gdb or list(map(int, gdb_version_number)) < [7, 2]:
             self.p = None
             warnings.warn('Skipping gdb tests, need gdb >= 7.2')
         else:
@@ -186,7 +189,7 @@ class TestAll(GdbDebuggerTestCase):
         border = '*' * 30
         start = '%s   v INSIDE GDB v   %s' % (border, border)
         end   = '%s   ^ INSIDE GDB ^   %s' % (border, border)
-        errmsg = '\n%s\n%s%s' % (start, err, end)
+        errmsg = '\n%s\n%s%s' % (start, err.decode('UTF-8'), end)
         self.assertEquals(0, self.p.wait(), errmsg)
         sys.stderr.write(err)
 

Cython/Debugger/Tests/test_libcython_in_gdb.py

@@ -24,7 +24,6 @@ from Cython.Debugger import libcython
 from Cython.Debugger import libpython
 from Cython.Debugger.Tests import TestLibCython as test_libcython
 
-
 # for some reason sys.argv is missing in gdb
 sys.argv = ['gdb']
 
@@ -204,6 +203,7 @@ class TestStep(DebugStepperTestCase):
         self.assertEqual(str(pyframe.co_name), 'join')
         assert re.match(r'\d+    def join\(', result), result
 
+
 class TestNext(DebugStepperTestCase):
     
     def test_cython_next(self):
@@ -345,17 +345,18 @@ class TestExec(DebugTestCase):
         self.assertEqual('14', self.eval_command('some_random_var'))
 
 
-_do_debug = os.environ.get('CYTHON_GDB_DEBUG')
+_do_debug = os.environ.get('GDB_DEBUG')
 if _do_debug:
     _debug_file = open('/dev/tty', 'w')
 
 def _debug(*messages):
     if _do_debug:
-        messages = itertools.chain([sys._getframe(1).f_code.co_name], 
+        messages = itertools.chain([sys._getframe(1).f_code.co_name, ':'], 
                                    messages)
         _debug_file.write(' '.join(str(msg) for msg in messages) + '\n')
 
-def _main():
+
+def run_unittest_in_module(modulename):
     try:
         gdb.lookup_type('PyModuleObject')
     except RuntimeError:
@@ -365,7 +366,7 @@ def _main():
         warnings.warn(msg)
         os._exit(1)
     else:
-        m = __import__(__name__, fromlist=[''])
+        m = __import__(modulename, fromlist=[''])
         tests = inspect.getmembers(m, inspect.isclass)
         
         # test_support.run_unittest(tests)
@@ -375,15 +376,29 @@ def _main():
             [test_loader.loadTestsFromTestCase(cls) for name, cls in tests])
         
         result = unittest.TextTestRunner(verbosity=1).run(suite)
-        if not result.wasSuccessful():
-            os._exit(1)
+        return result.wasSuccessful()
 
-def main(trace_code=False):
+def runtests():
+    """
+    Run the libcython and libpython tests. Ensure that an appropriate status is
+    returned to the parent test process.
+    """
+    from Cython.Debugger.Tests import test_libpython_in_gdb
+    
+    success_libcython = run_unittest_in_module(__name__)
+    success_libpython = run_unittest_in_module(test_libpython_in_gdb.__name__)
+    
+    if not success_libcython or not success_libpython:
+        sys.exit(1)
+    
+def main(version, trace_code=False):
+    global inferior_python_version 
+    
+    inferior_python_version = version
+    
     if trace_code:
         tracer = trace.Trace(count=False, trace=True, outfile=sys.stderr,
                             ignoredirs=[sys.prefix, sys.exec_prefix])
-        tracer.runfunc(_main)
+        tracer.runfunc(runtests)
     else:
-        _main()
-
-main()
+        runtests()

Cython/Debugger/Tests/test_libpython_in_gdb.py

+# -*- coding: UTF-8 -*-
+
+"""
+Test libpython.py. This is already partly tested by test_libcython_in_gdb and 
+Lib/test/test_gdb.py in the Python source. These tests are run in gdb and
+called from test_libcython_in_gdb.main()
+"""
+
+import os
+import sys
+
+import gdb
+
+from Cython.Debugger import libcython
+from Cython.Debugger import libpython
+
+import test_libcython_in_gdb
+from test_libcython_in_gdb import _debug, inferior_python_version
+
+
+class TestPrettyPrinters(test_libcython_in_gdb.DebugTestCase):
+    """
+    Test whether types of Python objects are correctly inferred and that
+    the right libpython.PySomeTypeObjectPtr classes are instantiated.
+    
+    Also test whether values are appropriately formatted (don't be too 
+    laborious as Lib/test/test_gdb.py already covers this extensively).
+    
+    Don't take care of decreffing newly allocated objects as a new 
+    interpreter is started for every test anyway.
+    """
+    
+    def setUp(self):
+        super(TestPrettyPrinters, self).setUp()
+        self.break_and_run('b = c = d = 0')
+    
+    def get_pyobject(self, code):
+        value = gdb.parse_and_eval(code)
+        assert libpython.pointervalue(value) != 0
+        return value
+    
+    def pyobject_fromcode(self, code, gdbvar=None):
+        if gdbvar is not None:
+            d = {'varname':gdbvar, 'code':code}
+            gdb.execute('set $%(varname)s = %(code)s' % d)
+            code = '$' + gdbvar
+            
+        return libpython.PyObjectPtr.from_pyobject_ptr(self.get_pyobject(code))
+    
+    def get_repr(self, pyobject):
+        return pyobject.get_truncated_repr(libpython.MAX_OUTPUT_LEN)
+    
+    def alloc_bytestring(self, string, gdbvar=None):
+        if inferior_python_version < (3, 0):
+            funcname = 'PyString_FromString'
+        else:
+            funcname = 'PyBytes_FromString'
+        
+        assert '"' not in string
+        
+        # ensure double quotes
+        code = '(PyObject *) %s("%s")' % (funcname, string)
+        return self.pyobject_fromcode(code, gdbvar=gdbvar)
+        
+    def alloc_unicodestring(self, string, gdbvar=None):
+        self.alloc_bytestring(string.encode('UTF-8'), gdbvar='_temp')
+        
+        postfix = libpython.get_inferior_unicode_postfix()
+        funcname = 'PyUnicode%s_FromEncodedObject' % (postfix,)
+        
+        return self.pyobject_fromcode(
+            '(PyObject *) %s($_temp, "UTF-8", "strict")' % funcname, 
+            gdbvar=gdbvar)
+        
+    def test_bytestring(self):
+        bytestring = self.alloc_bytestring("spam")
+        
+        if inferior_python_version < (3, 0):
+            bytestring_class = libpython.PyStringObjectPtr
+            expected = repr("spam")
+        else:
+            bytestring_class = libpython.PyBytesObjectPtr
+            expected = "b'spam'"
+        
+        self.assertEqual(type(bytestring), bytestring_class)
+        self.assertEqual(self.get_repr(bytestring), expected)
+    
+    def test_unicode(self):
+        unicode_string = self.alloc_unicodestring(u"spam ἄλφα")
+        
+        expected = "'spam ἄλφα'"
+        if inferior_python_version < (3, 0):
+            expected = 'u' + expected
+        
+        self.assertEqual(type(unicode_string), libpython.PyUnicodeObjectPtr)
+        self.assertEqual(self.get_repr(unicode_string), expected)
+    
+    def test_int(self):
+        if inferior_python_version < (3, 0):
+            intval = self.pyobject_fromcode('PyInt_FromLong(100)')
+            self.assertEqual(type(intval), libpython.PyIntObjectPtr)
+            self.assertEqual(self.get_repr(intval), '100')
+    
+    def test_long(self):
+        longval = self.pyobject_fromcode('PyLong_FromLong(200)', 
+                                         gdbvar='longval')
+        assert gdb.parse_and_eval('$longval->ob_type == &PyLong_Type')
+        
+        self.assertEqual(type(longval), libpython.PyLongObjectPtr)
+        self.assertEqual(self.get_repr(longval), '200')
+        
+    def test_frame_type(self):
+        frame = self.pyobject_fromcode('PyEval_GetFrame()')
+        
+        self.assertEqual(type(frame), libpython.PyFrameObjectPtr)
+
+    
\ No newline at end of file

runtests.py

@@ -644,8 +644,8 @@ class CythonUnitTestCase(CythonCompileTestCase):
         except Exception:
             pass
 
-# TODO: Re-enable once they're more robust.
-include_debugger = sys.version_info[:2] >= (2, 5) and False
+
+include_debugger = sys.version_info[:2] > (2, 5)
 
 def collect_unittests(path, module_prefix, suite, selectors):
     def file_matches(filename):

setup.py

@@ -71,7 +71,7 @@ else:
 setuptools_extra_args = {}
 
 # tells whether to include cygdb (the script and the Cython.Debugger package
-include_debugger = sys.version_info[:2] >= (2, 5)
+include_debugger = sys.version_info[:2] > (2, 5)
 
 if 'setuptools' in sys.modules:
     setuptools_extra_args['zip_safe'] = False