Add Python 2.7 support

vstinner · vstinner · commit a5e3ca17672e · 2020-12-04T22:29:30.000+01:00
Add tests/utils.py
diff --git a/.travis.yml b/.travis.yml
@@ -4,10 +4,12 @@ dist: bionic
 jobs:
   fast_finish: true
   include:
+    - python: '2.7'
+    - python: '3.5'
     - python: '3.6'
     - python: '3.7'
     - python: '3.8'
-    - python: '3.9-dev'
+    - python: '3.9'
     - python: nightly
 
 script:
diff --git a/README.rst b/README.rst
@@ -9,14 +9,15 @@ Python C API compatibility
 The Python C API compatibility project is made of two parts:
 
 * ``pythoncapi_compat.h``: Header file providing new functions of the Python C
-  API to Python 3.6.
+  API to old Python versions.
 * ``upgrade_pythoncapi.py``: Script upgrading C extension modules to newer
-  Python API without losing support for Python 3.6. It relies on
+  Python API without losing support for old Python versions. It relies on
   ``pythoncapi_compat.h``.
 
-Python 3.6 to Python 3.10 are supported. A subset of C99 is required, like
+Python 2.7 to Python 3.10 are supported. A subset of C99 is required, like
 ``static inline`` functions: see `PEP 7
-<https://www.python.org/dev/peps/pep-0007/>`_.
+<https://www.python.org/dev/peps/pep-0007/>`_. ISO C90 is partially supported
+for Python 2.7.
 
 Homepage:
 https://github.com/pythoncapi/pythoncapi_compat
@@ -194,7 +195,7 @@ PyThreadState::
 
     PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate);
     PyInterpreterState* PyThreadState_GetInterpreter(PyThreadState *tstate);
-    // Availability: Python 3.7+
+    // Availability: Python 3.7
     uint64_t PyThreadState_GetID(PyThreadState *tstate);
 
 PyInterpreterState::
@@ -204,7 +205,7 @@ PyInterpreterState::
 GC protocol::
 
     int PyObject_GC_IsTracked(PyObject* obj);
-    // Availability: Python 3.4+
+    // Availability: Python 3.4
     int PyObject_GC_IsFinalized(PyObject *obj);
 
 Module helper::
diff --git a/pythoncapi_compat.h b/pythoncapi_compat.h
@@ -1,4 +1,5 @@
-// Header file providing new functions of the Python C API to Python 3.6.
+// Header file providing new functions of the Python C API to old Python
+// versions.
 //
 // File distributed under the MIT license.
 //
diff --git a/runtests.py b/runtests.py
@@ -7,18 +7,31 @@
     python3 test_matrix.py
     python3 test_matrix.py -v # verbose mode
 """
+from __future__ import absolute_import
+from __future__ import print_function
 import argparse
 import os.path
 import shutil
 import subprocess
 import sys
+try:
+    from shutil import which
+except ImportError:
+    # Python 2
+    from distutils.spawn import find_executable as which
+
+
+from tests.utils import run_command
 
 
 TEST_DIR = os.path.join(os.path.dirname(__file__), 'tests')
 TEST_COMPAT = os.path.join(TEST_DIR, "test_pythoncapi_compat.py")
 TEST_UPGRADE = os.path.join(TEST_DIR, "test_upgrade_pythoncapi.py")
 
 PYTHONS = (
+    "python2.7",
+    "python3.4",
+    "python3.5",
     "python3.6",
     "python3.7",
     "python3.8",
@@ -29,14 +42,6 @@
 )
 
 
-def run_command(cmd):
-    proc = subprocess.Popen(cmd)
-    proc.wait()
-    exitcode = proc.returncode
-    if exitcode:
-        sys.exit(exitcode)
-
-
 def run_tests_exe(executable, verbose, tested):
     executable = os.path.realpath(executable)
     if executable in tested:
@@ -50,9 +55,9 @@ def run_tests_exe(executable, verbose, tested):
 
 
 def run_tests(python, verbose, tested):
-    executable = shutil.which(python)
+    executable = which(python)
     if not executable:
-        print(f"Ignore missing: {python}")
+        print("Ignore missing: %s" % python)
         return
     run_tests_exe(executable, verbose, tested)
 
@@ -70,10 +75,14 @@ def parse_args():
 def main():
     args = parse_args()
 
-    cmd = [sys.executable, TEST_UPGRADE]
-    if args.verbose:
-        cmd.append('-v')
-    run_command(cmd)
+    # upgrade_pythoncapi.py requires Python 3.6 or newer
+    if sys.version_info >= (3, 6):
+        cmd = [sys.executable, TEST_UPGRADE]
+        if args.verbose:
+            cmd.append('-v')
+        run_command(cmd)
+    else:
+        print("Don't test upgrade_pythoncapi.py: it requires Python 3.6")
     print()
 
     tested = set()
@@ -83,7 +92,7 @@ def main():
         run_tests_exe(sys.executable, args.verbose, tested)
 
         print()
-        print(f"Tested: {len(tested)} Python executables")
+        print("Tested: %s Python executables" % len(tested))
     else:
         run_tests_exe(sys.executable, args.verbose, tested)
 
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/test_pythoncapi_compat.py b/tests/test_pythoncapi_compat.py
@@ -7,21 +7,23 @@
     python3 run_tests.py
     python3 run_tests.py -v # verbose mode
 """
-import faulthandler
+from __future__ import absolute_import
+from __future__ import print_function
 import os.path
 import shutil
 import subprocess
 import sys
+try:
+    import faulthandler
+except ImportError:
+    # Python 2
+    faulthandler = None
 
-
-VERBOSE = False
+# test.utils
+from utils import run_command, command_stdout
 
 
-def run_command(args, **kw):
-    proc = subprocess.run(args)
-    if proc.returncode:
-        sys.exit(proc.returncode)
-    return proc
+VERBOSE = False
 
 
 def display_title(title):
@@ -43,13 +45,10 @@ def build_ext():
         run_command(cmd)
         print()
     else:
-        proc = subprocess.run(cmd,
-                              stdout=subprocess.PIPE,
-                              stderr=subprocess.STDOUT,
-                              universal_newlines=True)
-        if proc.returncode:
-            print(proc.stdout.rstrip())
-            sys.exit(proc.returncode)
+        exitcode, stdout = command_stdout(cmd, stderr=subprocess.STDOUT)
+        if exitcode:
+            print(stdout.rstrip())
+            sys.exit(exitcode)
 
 
 def import_tests():
@@ -68,7 +67,8 @@ def import_tests():
 def _run_tests(tests, verbose):
     for name, test_func in tests:
         if verbose:
-            print(f"{name}()", flush=True)
+            print("%s()" % name)
+            sys.stdout.flush()
         test_func()
 
 
@@ -78,14 +78,14 @@ def _check_refleak(test_func, verbose):
         if verbose:
             if i > 1:
                 print()
-            print(f"Run {i}/{nrun}:")
+            print("Run %s/%s:" % (i, nrun))
 
         init_refcnt = sys.gettotalrefcount()
         test_func()
         diff = sys.gettotalrefcount() - init_refcnt
 
         if i > 3 and diff:
-            raise AssertionError(f"refcnt leak, diff: {diff}")
+            raise AssertionError("refcnt leak, diff: %s" % diff)
 
 
 def run_tests(testmod):
@@ -110,18 +110,19 @@ def test_func():
 
     ver = sys.version_info
     build = 'debug' if hasattr(sys, 'gettotalrefcount') else 'release'
-    msg = f"{len(tests)} tests succeeded!"
-    msg = f"Python {ver.major}.{ver.minor} ({build} build): {msg}"
+    msg = "%s tests succeeded!" % len(tests)
+    msg = "Python %s.%s (%s build): %s" % (ver.major, ver.minor, build, msg)
     if check_refleak:
-        msg = f"{msg} (no reference leak detected)"
+        msg = "%s (no reference leak detected)" % msg
     print(msg)
 
 
 def main():
     global VERBOSE
     VERBOSE = "-v" in sys.argv[1:]
 
-    faulthandler.enable()
+    if faulthandler is not None:
+        faulthandler.enable()
 
     src_dir = os.path.dirname(__file__)
     if src_dir:
diff --git a/tests/test_pythoncapi_compat_cext.c b/tests/test_pythoncapi_compat_cext.c
@@ -3,6 +3,10 @@
 
 #include "pythoncapi_compat.h"
 
+#if PY_VERSION_HEX >= 0x03000000
+#  define PYTHON3 1
+#endif
+
 static PyObject*
 ASSERT_FAILED(const char *err_msg)
 {
@@ -196,31 +200,44 @@ test_gc(PyObject *self, PyObject *ignored)
 static PyObject *
 test_module(PyObject *self, PyObject *ignored)
 {
-    PyObject *module = self;
+    PyObject *module = PyImport_ImportModule("sys");
+    if (module == NULL) {
+        return NULL;
+    }
     assert(PyModule_Check(module));
 
     // test PyModule_AddType()
     PyTypeObject *type = &PyUnicode_Type;
+#ifdef PYTHON3
+    const char *type_name = "str";
+#else
+    const char *type_name = "unicode";
+#endif
     Py_ssize_t refcnt = Py_REFCNT(type);
 
     if (PyModule_AddType(module, type) < 0) {
-        return NULL;
+        goto error;
     }
     assert(Py_REFCNT(type) == refcnt + 1);
 
-    PyObject *attr = PyObject_GetAttrString(module, "str");
+    PyObject *attr = PyObject_GetAttrString(module, type_name);
     if (attr == NULL) {
-        return NULL;
+        goto error;
     }
     assert(attr == (PyObject *)type);
     Py_DECREF(attr);
 
-    if (PyObject_DelAttrString(module, "str") < 0) {
-        return NULL;
+    if (PyObject_DelAttrString(module, type_name) < 0) {
+        goto error;
     }
     assert(Py_REFCNT(type) == refcnt);
 
+    Py_DECREF(module);
     Py_RETURN_NONE;
+
+error:
+    Py_DECREF(module);
+    return NULL;
 }
 
 
@@ -236,15 +253,38 @@ static struct PyMethodDef methods[] = {
 };
 
 
+#ifdef PYTHON3
 static struct PyModuleDef module = {
     PyModuleDef_HEAD_INIT,
     .m_name = "test_pythoncapi_compat_cext",
     .m_methods = methods,
 };
 
 
+#if PY_VERSION_HEX >= 0x03050000
 PyMODINIT_FUNC
 PyInit_test_pythoncapi_compat_cext(void)
 {
     return PyModuleDef_Init(&module);
 }
+#else
+// Python 3.4
+PyMODINIT_FUNC
+PyInit_test_pythoncapi_compat_cext(void)
+{
+    return PyModule_Create(&module);
+}
+#endif
+
+#else
+// Python 2
+PyMODINIT_FUNC
+inittest_pythoncapi_compat_cext(void)
+{
+    Py_InitModule4("test_pythoncapi_compat_cext",
+                   methods,
+                   NULL,
+                   NULL,
+                   PYTHON_API_VERSION);
+}
+#endif
diff --git a/tests/utils.py b/tests/utils.py
@@ -0,0 +1,41 @@
+import subprocess
+import sys
+
+
+PYTHON3 = (sys.version_info >= (3,))
+
+
+def run_command(cmd, **kw):
+    if hasattr(subprocess, 'run'):
+        proc = subprocess.run(cmd, **kw)
+    else:
+        kw['shell'] = False
+        proc = subprocess.Popen(cmd, **kw)
+        try:
+            proc.wait()
+        except:
+            proc.kill()
+            proc.wait()
+            raise
+
+    exitcode = proc.returncode
+    if exitcode:
+        sys.exit(exitcode)
+
+
+def command_stdout(cmd, **kw):
+    kw['stdout'] = subprocess.PIPE
+    kw['universal_newlines'] = True
+    if hasattr(subprocess, 'run'):
+        proc = subprocess.run(cmd, **kw)
+        return (proc.returncode, proc.stdout)
+    else:
+        kw['shell'] = False
+        proc = subprocess.Popen(cmd, **kw)
+        try:
+            stdout = proc.communicate()[0]
+        except:
+            proc.kill()
+            proc.wait()
+            raise
+        return (proc.returncode, stdout)
