bpo-34272: Reorganize C API tests.

Move most C API tests into Lib/test/test_capi/.

Author: serhiy-storchaka

Lib/test/test_bytes.py

@@ -820,114 +820,6 @@ def __bytes__(self):
         self.assertEqual(BytesSubclass(A()), b'abc')
         self.assertIs(type(BytesSubclass(A())), BytesSubclass)
 
-    # Test PyBytes_FromFormat()
-    def test_from_format(self):
-        ctypes = test.support.import_module('ctypes')
-        _testcapi = test.support.import_module('_testcapi')
-        from ctypes import pythonapi, py_object
-        from ctypes import (
-            c_int, c_uint,
-            c_long, c_ulong,
-            c_size_t, c_ssize_t,
-            c_char_p)
-
-        PyBytes_FromFormat = pythonapi.PyBytes_FromFormat
-        PyBytes_FromFormat.restype = py_object
-
-        # basic tests
-        self.assertEqual(PyBytes_FromFormat(b'format'),
-                         b'format')
-        self.assertEqual(PyBytes_FromFormat(b'Hello %s !', b'world'),
-                         b'Hello world !')
-
-        # test formatters
-        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(0)),
-                         b'c=\0')
-        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(ord('@'))),
-                         b'c=@')
-        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(255)),
-                         b'c=\xff')
-        self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
-                                            c_int(1), c_long(2),
-                                            c_size_t(3)),
-                         b'd=1 ld=2 zd=3')
-        self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
-                                            c_int(-1), c_long(-2),
-                                            c_size_t(-3)),
-                         b'd=-1 ld=-2 zd=-3')
-        self.assertEqual(PyBytes_FromFormat(b'u=%u lu=%lu zu=%zu',
-                                            c_uint(123), c_ulong(456),
-                                            c_size_t(789)),
-                         b'u=123 lu=456 zu=789')
-        self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(123)),
-                         b'i=123')
-        self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(-123)),
-                         b'i=-123')
-        self.assertEqual(PyBytes_FromFormat(b'x=%x', c_int(0xabc)),
-                         b'x=abc')
-
-        sizeof_ptr = ctypes.sizeof(c_char_p)
-
-        if os.name == 'nt':
-            # Windows (MSCRT)
-            ptr_format = '0x%0{}X'.format(2 * sizeof_ptr)
-            def ptr_formatter(ptr):
-                return (ptr_format % ptr)
-        else:
-            # UNIX (glibc)
-            def ptr_formatter(ptr):
-                return '%#x' % ptr
-
-        ptr = 0xabcdef
-        self.assertEqual(PyBytes_FromFormat(b'ptr=%p', c_char_p(ptr)),
-                         ('ptr=' + ptr_formatter(ptr)).encode('ascii'))
-        self.assertEqual(PyBytes_FromFormat(b's=%s', c_char_p(b'cstr')),
-                         b's=cstr')
-
-        # test minimum and maximum integer values
-        size_max = c_size_t(-1).value
-        for formatstr, ctypes_type, value, py_formatter in (
-            (b'%d', c_int, _testcapi.INT_MIN, str),
-            (b'%d', c_int, _testcapi.INT_MAX, str),
-            (b'%ld', c_long, _testcapi.LONG_MIN, str),
-            (b'%ld', c_long, _testcapi.LONG_MAX, str),
-            (b'%lu', c_ulong, _testcapi.ULONG_MAX, str),
-            (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MIN, str),
-            (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MAX, str),
-            (b'%zu', c_size_t, size_max, str),
-            (b'%p', c_char_p, size_max, ptr_formatter),
-        ):
-            self.assertEqual(PyBytes_FromFormat(formatstr, ctypes_type(value)),
-                             py_formatter(value).encode('ascii')),
-
-        # width and precision (width is currently ignored)
-        self.assertEqual(PyBytes_FromFormat(b'%5s', b'a'),
-                         b'a')
-        self.assertEqual(PyBytes_FromFormat(b'%.3s', b'abcdef'),
-                         b'abc')
-
-        # '%%' formatter
-        self.assertEqual(PyBytes_FromFormat(b'%%'),
-                         b'%')
-        self.assertEqual(PyBytes_FromFormat(b'[%%]'),
-                         b'[%]')
-        self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))),
-                         b'%_')
-        self.assertEqual(PyBytes_FromFormat(b'%%s'),
-                         b'%s')
-
-        # Invalid formats and partial formatting
-        self.assertEqual(PyBytes_FromFormat(b'%'), b'%')
-        self.assertEqual(PyBytes_FromFormat(b'x=%i y=%', c_int(2), c_int(3)),
-                         b'x=2 y=%')
-
-        # Issue #19969: %c must raise OverflowError for values
-        # not in the range [0; 255]
-        self.assertRaises(OverflowError,
-                          PyBytes_FromFormat, b'%c', c_int(-1))
-        self.assertRaises(OverflowError,
-                          PyBytes_FromFormat, b'%c', c_int(256))
-
     def test_bytes_blocking(self):
         class IterationBlocked(list):
             __bytes__ = None

Lib/test/test_capi/__init__.py

@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)

Lib/test/test_capi/__main__.py

@@ -0,0 +1,3 @@
+import unittest
+
+unittest.main('test.test_capi')

Lib/test/test_capi/test_bytes.py

@@ -0,0 +1,118 @@
+import os
+import unittest
+from test import support
+
+
+class CAPITest(unittest.TestCase):
+
+    # Test PyBytes_FromFormat()
+    def test_from_format(self):
+        ctypes = support.import_module('ctypes')
+        _testcapi = support.import_module('_testcapi')
+        from ctypes import pythonapi, py_object
+        from ctypes import (
+            c_int, c_uint,
+            c_long, c_ulong,
+            c_size_t, c_ssize_t,
+            c_char_p)
+
+        PyBytes_FromFormat = pythonapi.PyBytes_FromFormat
+        PyBytes_FromFormat.restype = py_object
+
+        # basic tests
+        self.assertEqual(PyBytes_FromFormat(b'format'),
+                         b'format')
+        self.assertEqual(PyBytes_FromFormat(b'Hello %s !', b'world'),
+                         b'Hello world !')
+
+        # test formatters
+        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(0)),
+                         b'c=\0')
+        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(ord('@'))),
+                         b'c=@')
+        self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(255)),
+                         b'c=\xff')
+        self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
+                                            c_int(1), c_long(2),
+                                            c_size_t(3)),
+                         b'd=1 ld=2 zd=3')
+        self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
+                                            c_int(-1), c_long(-2),
+                                            c_size_t(-3)),
+                         b'd=-1 ld=-2 zd=-3')
+        self.assertEqual(PyBytes_FromFormat(b'u=%u lu=%lu zu=%zu',
+                                            c_uint(123), c_ulong(456),
+                                            c_size_t(789)),
+                         b'u=123 lu=456 zu=789')
+        self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(123)),
+                         b'i=123')
+        self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(-123)),
+                         b'i=-123')
+        self.assertEqual(PyBytes_FromFormat(b'x=%x', c_int(0xabc)),
+                         b'x=abc')
+
+        sizeof_ptr = ctypes.sizeof(c_char_p)
+
+        if os.name == 'nt':
+            # Windows (MSCRT)
+            ptr_format = '0x%0{}X'.format(2 * sizeof_ptr)
+            def ptr_formatter(ptr):
+                return (ptr_format % ptr)
+        else:
+            # UNIX (glibc)
+            def ptr_formatter(ptr):
+                return '%#x' % ptr
+
+        ptr = 0xabcdef
+        self.assertEqual(PyBytes_FromFormat(b'ptr=%p', c_char_p(ptr)),
+                         ('ptr=' + ptr_formatter(ptr)).encode('ascii'))
+        self.assertEqual(PyBytes_FromFormat(b's=%s', c_char_p(b'cstr')),
+                         b's=cstr')
+
+        # test minimum and maximum integer values
+        size_max = c_size_t(-1).value
+        for formatstr, ctypes_type, value, py_formatter in (
+            (b'%d', c_int, _testcapi.INT_MIN, str),
+            (b'%d', c_int, _testcapi.INT_MAX, str),
+            (b'%ld', c_long, _testcapi.LONG_MIN, str),
+            (b'%ld', c_long, _testcapi.LONG_MAX, str),
+            (b'%lu', c_ulong, _testcapi.ULONG_MAX, str),
+            (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MIN, str),
+            (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MAX, str),
+            (b'%zu', c_size_t, size_max, str),
+            (b'%p', c_char_p, size_max, ptr_formatter),
+        ):
+            self.assertEqual(PyBytes_FromFormat(formatstr, ctypes_type(value)),
+                             py_formatter(value).encode('ascii')),
+
+        # width and precision (width is currently ignored)
+        self.assertEqual(PyBytes_FromFormat(b'%5s', b'a'),
+                         b'a')
+        self.assertEqual(PyBytes_FromFormat(b'%.3s', b'abcdef'),
+                         b'abc')
+
+        # '%%' formatter
+        self.assertEqual(PyBytes_FromFormat(b'%%'),
+                         b'%')
+        self.assertEqual(PyBytes_FromFormat(b'[%%]'),
+                         b'[%]')
+        self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))),
+                         b'%_')
+        self.assertEqual(PyBytes_FromFormat(b'%%s'),
+                         b'%s')
+
+        # Invalid formats and partial formatting
+        self.assertEqual(PyBytes_FromFormat(b'%'), b'%')
+        self.assertEqual(PyBytes_FromFormat(b'x=%i y=%', c_int(2), c_int(3)),
+                         b'x=2 y=%')
+
+        # Issue #19969: %c must raise OverflowError for values
+        # not in the range [0; 255]
+        self.assertRaises(OverflowError,
+                          PyBytes_FromFormat, b'%c', c_int(-1))
+        self.assertRaises(OverflowError,
+                          PyBytes_FromFormat, b'%c', c_int(256))
+
+
+if __name__ == "__main__":
+    unittest.main()

Lib/test/test_capi/test_dict.py

@@ -0,0 +1,36 @@
+import unittest
+from test import support
+
+
+class CAPITest(unittest.TestCase):
+
+    # Test _PyDict_GetItem_KnownHash()
+    @support.cpython_only
+    def test_getitem_knownhash(self):
+        from _testcapi import dict_getitem_knownhash
+
+        d = {'x': 1, 'y': 2, 'z': 3}
+        self.assertEqual(dict_getitem_knownhash(d, 'x', hash('x')), 1)
+        self.assertEqual(dict_getitem_knownhash(d, 'y', hash('y')), 2)
+        self.assertEqual(dict_getitem_knownhash(d, 'z', hash('z')), 3)
+
+        # not a dict
+        self.assertRaises(SystemError, dict_getitem_knownhash, [], 1, hash(1))
+        # key does not exist
+        self.assertRaises(KeyError, dict_getitem_knownhash, {}, 1, hash(1))
+
+        class Exc(Exception): pass
+        class BadEq:
+            def __eq__(self, other):
+                raise Exc
+            def __hash__(self):
+                return 7
+
+        k1, k2 = BadEq(), BadEq()
+        d = {k1: 1}
+        self.assertEqual(dict_getitem_knownhash(d, k1, hash(k1)), 1)
+        self.assertRaises(Exc, dict_getitem_knownhash, d, k2, hash(k2))
+
+
+if __name__ == "__main__":
+    unittest.main()

Lib/test/test_getargs2.py renamed to Lib/test/test_capi/test_getargs.py

@@ -0,0 +1,94 @@
+from test import support
+import marshal
+import unittest
+
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+
+@support.cpython_only
+@unittest.skipUnless(_testcapi, 'requires _testcapi')
+class CAPI_TestCase(unittest.TestCase):
+
+    def test_write_long_to_file(self):
+        for v in range(marshal.version + 1):
+            _testcapi.pymarshal_write_long_to_file(0x12345678, support.TESTFN, v)
+            with open(support.TESTFN, 'rb') as f:
+                data = f.read()
+            support.unlink(support.TESTFN)
+            self.assertEqual(data, b'\x78\x56\x34\x12')
+
+    def test_write_object_to_file(self):
+        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j, 'long line '*1000)
+        for v in range(marshal.version + 1):
+            _testcapi.pymarshal_write_object_to_file(obj, support.TESTFN, v)
+            with open(support.TESTFN, 'rb') as f:
+                data = f.read()
+            support.unlink(support.TESTFN)
+            self.assertEqual(marshal.loads(data), obj)
+
+    def test_read_short_from_file(self):
+        with open(support.TESTFN, 'wb') as f:
+            f.write(b'\x34\x12xxxx')
+        r, p = _testcapi.pymarshal_read_short_from_file(support.TESTFN)
+        support.unlink(support.TESTFN)
+        self.assertEqual(r, 0x1234)
+        self.assertEqual(p, 2)
+
+        with open(support.TESTFN, 'wb') as f:
+            f.write(b'\x12')
+        with self.assertRaises(EOFError):
+            _testcapi.pymarshal_read_short_from_file(support.TESTFN)
+        support.unlink(support.TESTFN)
+
+    def test_read_long_from_file(self):
+        with open(support.TESTFN, 'wb') as f:
+            f.write(b'\x78\x56\x34\x12xxxx')
+        r, p = _testcapi.pymarshal_read_long_from_file(support.TESTFN)
+        support.unlink(support.TESTFN)
+        self.assertEqual(r, 0x12345678)
+        self.assertEqual(p, 4)
+
+        with open(support.TESTFN, 'wb') as f:
+            f.write(b'\x56\x34\x12')
+        with self.assertRaises(EOFError):
+            _testcapi.pymarshal_read_long_from_file(support.TESTFN)
+        support.unlink(support.TESTFN)
+
+    def test_read_last_object_from_file(self):
+        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j)
+        for v in range(marshal.version + 1):
+            data = marshal.dumps(obj, v)
+            with open(support.TESTFN, 'wb') as f:
+                f.write(data + b'xxxx')
+            r, p = _testcapi.pymarshal_read_last_object_from_file(support.TESTFN)
+            support.unlink(support.TESTFN)
+            self.assertEqual(r, obj)
+
+            with open(support.TESTFN, 'wb') as f:
+                f.write(data[:1])
+            with self.assertRaises(EOFError):
+                _testcapi.pymarshal_read_last_object_from_file(support.TESTFN)
+            support.unlink(support.TESTFN)
+
+    def test_read_object_from_file(self):
+        obj = ('\u20ac', b'abc', 123, 45.6, 7+8j)
+        for v in range(marshal.version + 1):
+            data = marshal.dumps(obj, v)
+            with open(support.TESTFN, 'wb') as f:
+                f.write(data + b'xxxx')
+            r, p = _testcapi.pymarshal_read_object_from_file(support.TESTFN)
+            support.unlink(support.TESTFN)
+            self.assertEqual(r, obj)
+            self.assertEqual(p, len(data))
+
+            with open(support.TESTFN, 'wb') as f:
+                f.write(data[:1])
+            with self.assertRaises(EOFError):
+                _testcapi.pymarshal_read_object_from_file(support.TESTFN)
+            support.unlink(support.TESTFN)
+
+
+if __name__ == "__main__":
+    unittest.main()