Remove outdated Python pre-3.9 code

These are manual fixes

Author: DimitriPapadopoulos

src/c/test_c.py

@@ -101,14 +101,9 @@ def find_and_load_library(name, flags=RTLD_NOW):
         path = None
     else:
         path = ctypes.util.find_library(name)
-        if path is None and sys.platform == 'darwin' and sys.version_info[:2] == (3, 8):
-            pytest.xfail("find_library usually broken on MacOS Python 3.8")
         if path is None and name == 'c':
             assert sys.platform == 'win32'
-            assert (sys.version_info >= (3,) or
-                    '__pypy__' in sys.builtin_module_names)
-            pytest.skip("dlopen(None) cannot work on Windows "
-                         "with PyPy or Python 3")
+            pytest.skip("dlopen(None) cannot work on Windows")
     return load_library(path, flags)
 
 def test_load_library():

src/cffi/verifier.py

@@ -161,7 +161,7 @@ def _write_source(self, file=None):
             self._write_source_to(file)
         else:
             # Write our source file to an in memory file.
-            f = NativeIO()
+            f = io.StringIO()
             self._write_source_to(f)
             source_data = f.getvalue()
 

testing/cffi0/backend_tests.py

@@ -2,7 +2,6 @@
 import platform
 import sys, ctypes, ctypes.util
 from cffi import FFI, CDefError, FFIError, VerificationMissing
-from testing.support import *
 
 SIZE_OF_INT   = ctypes.sizeof(ctypes.c_int)
 SIZE_OF_LONG  = ctypes.sizeof(ctypes.c_long)
@@ -311,7 +310,7 @@ def test_char(self):
         assert bool(ffi.cast("char", 1))
         assert bool(ffi.cast("char", 255))
         pytest.raises(TypeError, ffi.new, "char*", 32)
-        pytest.raises(TypeError, ffi.new, "char*", u+"x")
+        pytest.raises(TypeError, ffi.new, "char*", "x")
         pytest.raises(TypeError, ffi.new, "char*", b"foo")
         #
         p = ffi.new("char[]", [b'a', b'b', b'\x9c'])
@@ -342,13 +341,13 @@ def check_wchar_t(self, ffi):
     def test_wchar_t(self):
         ffi = FFI(backend=self.Backend())
         self.check_wchar_t(ffi)
-        assert ffi.new("wchar_t*", u+'x')[0] == u+'x'
-        assert ffi.new("wchar_t*", u+'\u1234')[0] == u+'\u1234'
+        assert ffi.new("wchar_t*", 'x')[0] == 'x'
+        assert ffi.new("wchar_t*", '\u1234')[0] == '\u1234'
         if SIZE_OF_WCHAR > 2:
-            assert ffi.new("wchar_t*", u+'\U00012345')[0] == u+'\U00012345'
+            assert ffi.new("wchar_t*", '\U00012345')[0] == '\U00012345'
         else:
-            pytest.raises(TypeError, ffi.new, "wchar_t*", u+'\U00012345')
-        assert ffi.new("wchar_t*")[0] == u+'\x00'
+            pytest.raises(TypeError, ffi.new, "wchar_t*", '\U00012345')
+        assert ffi.new("wchar_t*")[0] == '\x00'
         assert int(ffi.cast("wchar_t", 300)) == 300
         assert not bool(ffi.cast("wchar_t", 0))
         assert bool(ffi.cast("wchar_t", 1))
@@ -358,40 +357,40 @@ def test_wchar_t(self):
         pytest.raises(TypeError, ffi.new, "wchar_t*", 32)
         pytest.raises(TypeError, ffi.new, "wchar_t*", "foo")
         #
-        p = ffi.new("wchar_t[]", [u+'a', u+'b', u+'\u1234'])
+        p = ffi.new("wchar_t[]", ['a', 'b', '\u1234'])
         assert len(p) == 3
-        assert p[0] == u+'a'
-        assert p[1] == u+'b' and type(p[1]) is unicode
-        assert p[2] == u+'\u1234'
-        p[0] = u+'x'
-        assert p[0] == u+'x' and type(p[0]) is unicode
-        p[1] = u+'\u1357'
-        assert p[1] == u+'\u1357'
-        p = ffi.new("wchar_t[]", u+"abcd")
+        assert p[0] == 'a'
+        assert p[1] == 'b' and type(p[1]) is str
+        assert p[2] == '\u1234'
+        p[0] = 'x'
+        assert p[0] == 'x' and type(p[0]) is str
+        p[1] = '\u1357'
+        assert p[1] == '\u1357'
+        p = ffi.new("wchar_t[]", "abcd")
         assert len(p) == 5
-        assert p[4] == u+'\x00'
-        p = ffi.new("wchar_t[]", u+"a\u1234b")
+        assert p[4] == '\x00'
+        p = ffi.new("wchar_t[]", "a\u1234b")
         assert len(p) == 4
-        assert p[1] == u+'\u1234'
+        assert p[1] == '\u1234'
         #
-        p = ffi.new("wchar_t[]", u+'\U00023456')
+        p = ffi.new("wchar_t[]", '\U00023456')
         if SIZE_OF_WCHAR == 2:
             assert len(p) == 3
-            assert p[0] == u+'\ud84d'
-            assert p[1] == u+'\udc56'
-            assert p[2] == u+'\x00'
+            assert p[0] == '\ud84d'
+            assert p[1] == '\udc56'
+            assert p[2] == '\x00'
         else:
             assert len(p) == 2
-            assert p[0] == u+'\U00023456'
-            assert p[1] == u+'\x00'
+            assert p[0] == '\U00023456'
+            assert p[1] == '\x00'
         #
-        p = ffi.new("wchar_t[4]", u+"ab")
+        p = ffi.new("wchar_t[4]", "ab")
         assert len(p) == 4
-        assert [p[i] for i in range(4)] == [u+'a', u+'b', u+'\x00', u+'\x00']
-        p = ffi.new("wchar_t[2]", u+"ab")
+        assert [p[i] for i in range(4)] == ['a', 'b', '\x00', '\x00']
+        p = ffi.new("wchar_t[2]", "ab")
         assert len(p) == 2
-        assert [p[i] for i in range(2)] == [u+'a', u+'b']
-        pytest.raises(IndexError, ffi.new, "wchar_t[2]", u+"abc")
+        assert [p[i] for i in range(2)] == ['a', 'b']
+        pytest.raises(IndexError, ffi.new, "wchar_t[2]", "abc")
 
     def test_none_as_null_doesnt_work(self):
         ffi = FFI(backend=self.Backend())
@@ -596,15 +595,15 @@ def test_string_from_char_pointer(self):
         assert str(x) == repr(x)
         assert ffi.string(x) == b"x"
         assert ffi.string(ffi.new("char*", b"\x00")) == b""
-        pytest.raises(TypeError, ffi.new, "char*", unicode("foo"))
+        pytest.raises(TypeError, ffi.new, "char*", "foo")
 
-    def test_unicode_from_wchar_pointer(self):
+    def test_string_from_wchar_pointer(self):
         ffi = FFI(backend=self.Backend())
         self.check_wchar_t(ffi)
-        x = ffi.new("wchar_t*", u+"x")
-        assert unicode(x) == unicode(repr(x))
-        assert ffi.string(x) == u+"x"
-        assert ffi.string(ffi.new("wchar_t*", u+"\x00")) == u+""
+        x = ffi.new("wchar_t*", "x")
+        assert str(x) == str(repr(x))
+        assert ffi.string(x) == "x"
+        assert ffi.string(ffi.new("wchar_t*", "\x00")) == ""
 
     def test_string_from_char_array(self):
         ffi = FFI(backend=self.Backend())
@@ -627,38 +626,38 @@ def test_string_from_char_array(self):
     def test_string_from_wchar_array(self):
         ffi = FFI(backend=self.Backend())
         self.check_wchar_t(ffi)
-        assert ffi.string(ffi.cast("wchar_t", "x")) == u+"x"
-        assert ffi.string(ffi.cast("wchar_t", u+"x")) == u+"x"
+        assert ffi.string(ffi.cast("wchar_t", "x")) == "x"
+        assert ffi.string(ffi.cast("wchar_t", "x")) == "x"
         x = ffi.cast("wchar_t", "x")
         assert str(x) == repr(x)
-        assert ffi.string(x) == u+"x"
+        assert ffi.string(x) == "x"
         #
-        p = ffi.new("wchar_t[]", u+"hello.")
-        p[5] = u+'!'
-        assert ffi.string(p) == u+"hello!"
-        p[6] = u+'\u04d2'
-        assert ffi.string(p) == u+"hello!\u04d2"
-        p[3] = u+'\x00'
-        assert ffi.string(p) == u+"hel"
-        assert ffi.string(p, 123) == u+"hel"
+        p = ffi.new("wchar_t[]", "hello.")
+        p[5] = '!'
+        assert ffi.string(p) == "hello!"
+        p[6] = '\u04d2'
+        assert ffi.string(p) == "hello!\u04d2"
+        p[3] = '\x00'
+        assert ffi.string(p) == "hel"
+        assert ffi.string(p, 123) == "hel"
         with pytest.raises(IndexError):
-            p[7] = u+'X'
+            p[7] = 'X'
         #
-        a = ffi.new("wchar_t[]", u+"hello\x00world")
+        a = ffi.new("wchar_t[]", "hello\x00world")
         assert len(a) == 12
         p = ffi.cast("wchar_t *", a)
-        assert ffi.string(p) == u+'hello'
-        assert ffi.string(p, 123) == u+'hello'
-        assert ffi.string(p, 5) == u+'hello'
-        assert ffi.string(p, 2) == u+'he'
+        assert ffi.string(p) == 'hello'
+        assert ffi.string(p, 123) == 'hello'
+        assert ffi.string(p, 5) == 'hello'
+        assert ffi.string(p, 2) == 'he'
 
     def test_fetch_const_char_p_field(self):
         # 'const' is ignored so far
         ffi = FFI(backend=self.Backend())
         ffi.cdef("struct foo { const char *name; };")
         t = ffi.new("const char[]", b"testing")
         s = ffi.new("struct foo*", [t])
-        assert type(s.name) not in (bytes, str, unicode)
+        assert type(s.name) not in (bytes, str)
         assert ffi.string(s.name) == b"testing"
         with pytest.raises(TypeError):
             s.name = None
@@ -670,10 +669,10 @@ def test_fetch_const_wchar_p_field(self):
         ffi = FFI(backend=self.Backend())
         self.check_wchar_t(ffi)
         ffi.cdef("struct foo { const wchar_t *name; };")
-        t = ffi.new("const wchar_t[]", u+"testing")
+        t = ffi.new("const wchar_t[]", "testing")
         s = ffi.new("struct foo*", [t])
-        assert type(s.name) not in (bytes, str, unicode)
-        assert ffi.string(s.name) == u+"testing"
+        assert type(s.name) not in (bytes, str)
+        assert ffi.string(s.name) == "testing"
         s.name = ffi.NULL
         assert s.name == ffi.NULL
 
@@ -793,7 +792,7 @@ def test_char_cast(self):
     def test_wchar_cast(self):
         ffi = FFI(backend=self.Backend())
         self.check_wchar_t(ffi)
-        p = ffi.cast("int", ffi.cast("wchar_t", u+'\u1234'))
+        p = ffi.cast("int", ffi.cast("wchar_t", '\u1234'))
         assert int(p) == 0x1234
         p = ffi.cast("long long", ffi.cast("wchar_t", -1))
         if SIZE_OF_WCHAR == 2:      # 2 bytes, unsigned
@@ -803,7 +802,7 @@ def test_wchar_cast(self):
             assert int(p) == -1
         else:                     # in general, it can be either signed or not
             assert int(p) in [-1, 0xffffffff]  # e.g. on arm, both cases occur
-        p = ffi.cast("int", u+'\u1234')
+        p = ffi.cast("int", '\u1234')
         assert int(p) == 0x1234
 
     def test_cast_array_to_charp(self):
@@ -1250,7 +1249,7 @@ def test_ffi_buffer_with_file(self):
             pytest.skip(str(e))
         f.write(ffi.buffer(a, 1000 * ffi.sizeof("int")))
         f.seek(0)
-        assert f.read() == arraytostring(array.array('i', range(1000)))
+        assert f.read() == array.array('i', range(1000)).tobytes()
         f.seek(0)
         b = ffi.new("int[]", 1005)
         f.readinto(ffi.buffer(b, 1000 * ffi.sizeof("int")))
@@ -1269,7 +1268,7 @@ def test_ffi_buffer_with_io(self):
             pytest.skip(str(e))
         f.write(ffi.buffer(a, 1000 * ffi.sizeof("int")))
         f.seek(0)
-        assert f.read() == arraytostring(array.array('i', range(1000)))
+        assert f.read() == array.array('i', range(1000)).tobytes()
         f.seek(0)
         b = ffi.new("int[]", 1005)
         f.readinto(ffi.buffer(b, 1000 * ffi.sizeof("int")))

testing/cffi0/test_ctypes.py

@@ -41,7 +41,3 @@ def test_nested_anonymous_union(self):
 
     def test_nested_anonymous_struct_2(self):
         pytest.skip("ctypes backend: not supported: nested anonymous union")
-
-    def test_CData_CType_2(self):
-        pytest.skip("ctypes backend: not supported in Python 3: CType")
-        backend_tests.BackendTests.test_CData_CType_2(self)

testing/cffi0/test_ffi_backend.py

@@ -1,7 +1,7 @@
 import sys, platform
 import pytest
 from testing.cffi0 import backend_tests, test_function, test_ownlib
-from testing.support import u
+
 from cffi import FFI
 import _cffi_backend
 
@@ -621,32 +621,32 @@ def test_char16_t(self):
         ffi = FFI()
         x = ffi.new("char16_t[]", 5)
         assert len(x) == 5 and ffi.sizeof(x) == 10
-        x[2] = u+'\u1324'
-        assert x[2] == u+'\u1324'
-        y = ffi.new("char16_t[]", u+'\u1234\u5678')
+        x[2] = '\u1324'
+        assert x[2] == '\u1324'
+        y = ffi.new("char16_t[]", '\u1234\u5678')
         assert len(y) == 3
-        assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00']
-        assert ffi.string(y) == u+'\u1234\u5678'
-        z = ffi.new("char16_t[]", u+'\U00012345')
+        assert list(y) == ['\u1234', '\u5678', '\x00']
+        assert ffi.string(y) == '\u1234\u5678'
+        z = ffi.new("char16_t[]", '\U00012345')
         assert len(z) == 3
-        assert list(z) == [u+'\ud808', u+'\udf45', u+'\x00']
-        assert ffi.string(z) == u+'\U00012345'
+        assert list(z) == ['\ud808', '\udf45', '\x00']
+        assert ffi.string(z) == '\U00012345'
 
     def test_char32_t(self):
         ffi = FFI()
         x = ffi.new("char32_t[]", 5)
         assert len(x) == 5 and ffi.sizeof(x) == 20
-        x[3] = u+'\U00013245'
-        assert x[3] == u+'\U00013245'
-        y = ffi.new("char32_t[]", u+'\u1234\u5678')
+        x[3] = '\U00013245'
+        assert x[3] == '\U00013245'
+        y = ffi.new("char32_t[]", '\u1234\u5678')
         assert len(y) == 3
-        assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00']
-        py_uni = u+'\U00012345'
+        assert list(y) == ['\u1234', '\u5678', '\x00']
+        py_uni = '\U00012345'
         z = ffi.new("char32_t[]", py_uni)
         assert len(z) == 2
-        assert list(z) == [py_uni, u+'\x00']    # maybe a 2-unichars string
+        assert list(z) == [py_uni, '\x00']    # maybe a 2-unichars string
         assert ffi.string(z) == py_uni
         if len(py_uni) == 1:    # 4-bytes unicodes in Python
-            s = ffi.new("char32_t[]", u+'\ud808\udf00')
+            s = ffi.new("char32_t[]", '\ud808\udf00')
             assert len(s) == 3
-            assert list(s) == [u+'\ud808', u+'\udf00', u+'\x00']
+            assert list(s) == ['\ud808', '\udf00', '\x00']

testing/cffi0/test_ownlib.py

@@ -3,7 +3,7 @@
 import pytest
 from cffi import FFI
 from cffi.backend_ctypes import CTypesBackend
-from testing.support import u, is_musl
+from testing.support import is_musl
 
 
 SOURCE = """\
@@ -164,13 +164,13 @@ def setup_class(cls):
             encoded = None
             if cls.Backend is not CTypesBackend:
                 try:
-                    unicode_name = u+'testownlibcaf\xe9'
+                    unicode_name = 'testownlibcaf\xe9'
                     encoded = unicode_name.encode(sys.getfilesystemencoding())
                     encoded = str(unicode_name)
                 except UnicodeEncodeError:
                     pass
             if encoded is None:
-                unicode_name = u+'testownlib'
+                unicode_name = 'testownlib'
                 encoded = str(unicode_name)
             subprocess.check_call(
                 "cc testownlib.c -shared -fPIC -o '%s.so'" % (encoded,),
@@ -357,9 +357,9 @@ def test_char16_char32_t(self):
             char32_t foo_4bytes(char32_t);
         """)
         lib = ffi.dlopen(self.module)
-        assert lib.foo_2bytes(u+'\u1234') == u+'\u125e'
-        assert lib.foo_4bytes(u+'\u1234') == u+'\u125e'
-        assert lib.foo_4bytes(u+'\U00012345') == u+'\U0001236f'
+        assert lib.foo_2bytes('\u1234') == '\u125e'
+        assert lib.foo_4bytes('\u1234') == '\u125e'
+        assert lib.foo_4bytes('\U00012345') == '\U0001236f'
 
     def test_modify_struct_value(self):
         if self.module is None:

testing/cffi0/test_parsing.py

@@ -368,12 +368,11 @@ def test_unknown_name():
     assert 'foobarbazunknown' in str(e.value)
 
 def test_redefine_common_type():
-    prefix = "" if sys.version_info < (3,) else "b"
     ffi = FFI()
     ffi.cdef("typedef char FILE;")
-    assert repr(ffi.cast("FILE", 123)) == "<cdata 'char' %s'{'>" % prefix
+    assert repr(ffi.cast("FILE", 123)) == "<cdata 'char' b'{'>"
     ffi.cdef("typedef char int32_t;")
-    assert repr(ffi.cast("int32_t", 123)) == "<cdata 'char' %s'{'>" % prefix
+    assert repr(ffi.cast("int32_t", 123)) == "<cdata 'char' b'{'>"
     ffi = FFI()
     ffi.cdef("typedef int bool, *FILE;")
     assert repr(ffi.cast("bool", 123)) == "<cdata 'int' 123>"

testing/cffi0/test_verify.py

@@ -264,8 +264,6 @@ def test_all_integer_and_float_types():
     for typename in typenames:
         foo = getattr(lib, 'foo_%s' % typename.replace(' ', '_'))
         assert foo(42) == 43
-        if sys.version < '3':
-            assert foo(long(44)) == 45
         assert foo(ffi.cast(typename, 46)) == 47
         pytest.raises(TypeError, foo, ffi.NULL)
         #
@@ -390,11 +388,11 @@ def test_char_type():
 def test_wchar_type():
     ffi = FFI()
     if ffi.sizeof('wchar_t') == 2:
-        uniexample1 = u+'\u1234'
-        uniexample2 = u+'\u1235'
+        uniexample1 = '\u1234'
+        uniexample2 = '\u1235'
     else:
-        uniexample1 = u+'\U00012345'
-        uniexample2 = u+'\U00012346'
+        uniexample1 = '\U00012345'
+        uniexample2 = '\U00012346'
     #
     ffi.cdef("wchar_t foo(wchar_t);")
     lib = ffi.verify("wchar_t foo(wchar_t x) { return x+1; }")