pythongh-105751: Cleanup test_ctypes imports (python#105803)

* Move imports at top level and sort imports.
* Replace c_buffer() with create_string_buffer(): c_buffer is a
  deprecated alias.
* PEP 8: Add empty lines for readability between imports and classes.

Author: vstinner

Lib/test/test_ctypes/test_anon.py

@@ -2,6 +2,7 @@
 import test.support
 from ctypes import c_int, Union, Structure, sizeof
 
+
 class AnonTest(unittest.TestCase):
 
     def test_anon(self):
@@ -69,5 +70,6 @@ class Y(Structure):
         self.assertEqual(Y._.offset, sizeof(c_int))
         self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
 
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_array_in_pointer.py

@@ -1,21 +1,24 @@
+import binascii
+import re
 import unittest
 from ctypes import c_byte, Structure, POINTER, cast
-from binascii import hexlify
-import re
+
 
 def dump(obj):
     # helper function to dump memory contents in hex, with a hyphen
     # between the bytes.
-    h = hexlify(memoryview(obj)).decode()
+    h = binascii.hexlify(memoryview(obj)).decode()
     return re.sub(r"(..)", r"\1-", h)[:-1]
 
 
 class Value(Structure):
     _fields_ = [("val", c_byte)]
 
+
 class Container(Structure):
     _fields_ = [("pvalues", POINTER(Value))]
 
+
 class Test(unittest.TestCase):
     def test(self):
         # create an array of 4 values
@@ -60,5 +63,6 @@ def test_2(self):
             ([1, 2, 3, 4], "01-02-03-04")
         )
 
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_as_parameter.py

@@ -16,9 +16,11 @@
     # fake to enable this test on Linux
     CALLBACK_FUNCTYPE = CFUNCTYPE
 
+
 class POINT(Structure):
     _fields_ = [("x", c_int), ("y", c_int)]
 
+
 class BasicWrapTestCase(unittest.TestCase):
     def wrap(self, param):
         return param
@@ -71,8 +73,6 @@ def callback(v):
         f(self.wrap(2**18), self.wrap(cb))
         self.assertEqual(args, expected)
 
-    ################################################################
-
     def test_callbacks(self):
         f = dll._testfunc_callback_i_if
         f.restype = c_int
@@ -194,8 +194,6 @@ class S8I(Structure):
                              (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
 
     def test_recursive_as_param(self):
-        from ctypes import c_int
-
         class A(object):
             pass
 
@@ -205,16 +203,13 @@ class A(object):
             c_int.from_param(a)
 
 
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 class AsParamWrapper(object):
     def __init__(self, param):
         self._as_parameter_ = param
 
 class AsParamWrapperTestCase(BasicWrapTestCase):
     wrap = AsParamWrapper
 
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 class AsParamPropertyWrapper(object):
     def __init__(self, param):
@@ -227,7 +222,6 @@ def getParameter(self):
 class AsParamPropertyWrapperTestCase(BasicWrapTestCase):
     wrap = AsParamPropertyWrapper
 
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 if __name__ == '__main__':
     unittest.main()

Lib/test/test_ctypes/test_bitfields.py

@@ -1,13 +1,13 @@
+import _ctypes_test
+import os
+import unittest
 from ctypes import (CDLL, Structure, sizeof, POINTER, byref, alignment,
                     LittleEndianStructure, BigEndianStructure,
                     c_byte, c_ubyte, c_char, c_char_p, c_void_p, c_wchar,
                     c_uint32, c_uint64,
                     c_short, c_ushort, c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong)
 from test import support
-import unittest
-import os
 
-import _ctypes_test
 
 class BITS(Structure):
     _fields_ = [("A", c_int, 1),
@@ -56,6 +56,7 @@ def test_shorts(self):
                 setattr(b, name, i)
                 self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
 
+
 signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
 unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
 int_types = unsigned_int_types + signed_int_types
@@ -117,7 +118,6 @@ class X(Structure):
             x.a, x.b = 0, -1
             self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
 
-
     def fail_fields(self, *fields):
         return self.get_except(type(Structure), "X", (),
                                {"_fields_": fields})
@@ -194,7 +194,6 @@ class X(Structure):
         self.assertEqual(X.b.offset, sizeof(c_short)*1)
         self.assertEqual(X.c.offset, sizeof(c_short)*2)
 
-
     def get_except(self, func, *args, **kw):
         try:
             func(*args, **kw)
@@ -291,5 +290,6 @@ class Big(BigEndianStructure):
         x.c = 2
         self.assertEqual(b, b'\xab\xcd\xef\x12')
 
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_buffers.py

@@ -1,9 +1,9 @@
+import unittest
 from ctypes import (create_string_buffer, create_unicode_buffer, sizeof,
                     c_char, c_wchar)
-import unittest
 
-class StringBufferTestCase(unittest.TestCase):
 
+class StringBufferTestCase(unittest.TestCase):
     def test_buffer(self):
         b = create_string_buffer(32)
         self.assertEqual(len(b), 32)

Lib/test/test_ctypes/test_bytes.py

@@ -1,8 +1,10 @@
 """Test where byte objects are accepted"""
 import sys
 import unittest
+from _ctypes import _SimpleCData
 from ctypes import Structure, c_char, c_char_p, c_wchar, c_wchar_p
 
+
 class BytesTest(unittest.TestCase):
     def test_c_char(self):
         x = c_char(b"x")
@@ -55,7 +57,6 @@ class X(Structure):
 
     @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
     def test_BSTR(self):
-        from _ctypes import _SimpleCData
         class BSTR(_SimpleCData):
             _type_ = "X"
 

Lib/test/test_ctypes/test_byteswap.py

@@ -1,6 +1,9 @@
-import sys, unittest, struct, math, ctypes
-from binascii import hexlify
-
+import binascii
+import ctypes
+import math
+import struct
+import sys
+import unittest
 from ctypes import (Structure, Union, LittleEndianUnion, BigEndianUnion,
                     BigEndianStructure, LittleEndianStructure,
                     POINTER, sizeof, cast,
@@ -9,8 +12,10 @@
                     c_long, c_ulong, c_longlong, c_ulonglong,
                     c_uint32, c_float, c_double)
 
+
 def bin(s):
-    return hexlify(memoryview(s)).decode().upper()
+    return binascii.hexlify(memoryview(s)).decode().upper()
+
 
 # Each *simple* type that supports different byte orders has an
 # __ctype_be__ attribute that specifies the same type in BIG ENDIAN
@@ -366,5 +371,6 @@ class TestUnion(parent):
                 self.assertEqual(s.point.x, 1)
                 self.assertEqual(s.point.y, 2)
 
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_callbacks.py

@@ -1,24 +1,25 @@
+import _ctypes_test
+import ctypes
 import functools
+import gc
+import math
 import sys
 import unittest
-from test import support
-
-import ctypes
+from _ctypes import CTYPES_MAX_ARGCOUNT
 from ctypes import (CDLL, cdll, Structure, CFUNCTYPE,
                     ArgumentError, POINTER, sizeof,
                     c_byte, c_ubyte, c_char, c_char_p,
                     c_short, c_ushort, c_int, c_uint,
                     c_long, c_longlong, c_ulonglong, c_ulong,
                     c_float, c_double, c_longdouble, py_object)
-from _ctypes import CTYPES_MAX_ARGCOUNT
-import _ctypes_test
+from ctypes.util import find_library
+from test import support
 
 
 class Callbacks(unittest.TestCase):
     functype = CFUNCTYPE
 
 ##    def tearDown(self):
-##        import gc
 ##        gc.collect()
 
     def callback(self, *args):
@@ -81,7 +82,6 @@ def test_ulonglong(self):
 
     def test_float(self):
         # only almost equal: double -> float -> double
-        import math
         self.check_type(c_float, math.e)
         self.check_type(c_float, -math.e)
 
@@ -138,7 +138,6 @@ def func(self): pass
             def __init__(self):
                 self.v = proto(self.func)
 
-        import gc
         for i in range(32):
             X()
         gc.collect()
@@ -147,7 +146,6 @@ def __init__(self):
         self.assertEqual(len(live), 0)
 
     def test_issue12483(self):
-        import gc
         class Nasty:
             def __del__(self):
                 gc.collect()
@@ -172,8 +170,6 @@ class StdcallCallbacks(Callbacks):
         functype = ctypes.WINFUNCTYPE
 
 
-################################################################
-
 class SampleCallbacksTestCase(unittest.TestCase):
 
     def test_integrate(self):
@@ -197,7 +193,6 @@ def func(x):
         self.assertLess(diff, 0.01, "%s not less than 0.01" % diff)
 
     def test_issue_8959_a(self):
-        from ctypes.util import find_library
         libc_path = find_library("c")
         if not libc_path:
             self.skipTest('could not find libc')

Lib/test/test_ctypes/test_cast.py

@@ -4,8 +4,8 @@
                     c_void_p, c_char_p, c_wchar_p,
                     c_byte, c_short, c_int)
 
-class Test(unittest.TestCase):
 
+class Test(unittest.TestCase):
     def test_array2pointer(self):
         array = (c_int * 3)(42, 17, 2)
 
@@ -80,7 +80,7 @@ def test_char_p(self):
     def test_wchar_p(self):
         s = c_wchar_p("hiho")
         self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
-                             "hiho")
+                         "hiho")
 
     def test_bad_type_arg(self):
         # The type argument must be a ctypes pointer type.
@@ -95,5 +95,6 @@ class MyUnion(Union):
             _fields_ = [("a", c_int)]
         self.assertRaises(TypeError, cast, array, MyUnion)
 
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ctypes/test_cfuncs.py

@@ -1,11 +1,11 @@
-import unittest
+import _ctypes_test
 import ctypes
+import unittest
 from ctypes import (CDLL,
                     c_byte, c_ubyte, c_char,
                     c_short, c_ushort, c_int, c_uint,
                     c_long, c_ulong, c_longlong, c_ulonglong,
                     c_float, c_double, c_longdouble)
-import _ctypes_test
 
 
 class CFunctions(unittest.TestCase):
@@ -190,6 +190,7 @@ def test_void(self):
         self.assertEqual(self._dll.tv_i(-42), None)
         self.assertEqual(self.S(), -42)
 
+
 # The following repeats the above tests with stdcall functions (where
 # they are available)
 if hasattr(ctypes, 'WinDLL'):