bpo-43988: Use check disallow instantiation helper (GH-26392)

Author: Erlend Egeberg Aasland

Lib/test/support/__init__.py

@@ -2001,5 +2001,11 @@ def check_disallow_instantiation(testcase, tp, *args, **kwds):
 
     See bpo-43916: Add Py_TPFLAGS_DISALLOW_INSTANTIATION type flag.
     """
-    msg = f"cannot create '{tp.__module__}\.{tp.__name__}' instances"
+    mod = tp.__module__
+    name = tp.__name__
+    if mod != 'builtins':
+        qualname = f"{mod}.{name}"
+    else:
+        qualname = f"{name}"
+    msg = f"cannot create '{re.escape(qualname)}' instances"
     testcase.assertRaisesRegex(TypeError, msg, tp, *args, **kwds)

Lib/test/test_array.py

@@ -43,8 +43,9 @@ def test_bad_constructor(self):
     @support.cpython_only
     def test_disallow_instantiation(self):
         my_array = array.array("I")
-        tp = type(iter(my_array))
-        support.check_disallow_instantiation(self, tp, my_array)
+        support.check_disallow_instantiation(
+            self, type(iter(my_array)), my_array
+        )
 
     @support.cpython_only
     def test_immutable(self):

Lib/test/test_curses.py

@@ -6,7 +6,8 @@
 import tempfile
 import unittest
 
-from test.support import requires, verbose, SaveSignals, cpython_only
+from test.support import (requires, verbose, SaveSignals, cpython_only,
+                          check_disallow_instantiation)
 from test.support.import_helper import import_module
 
 # Optionally test curses module.  This currently requires that the
@@ -1052,7 +1053,7 @@ def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
         w = curses.newwin(10, 10)
         panel = curses.panel.new_panel(w)
-        self.assertRaises(TypeError, type(panel))
+        check_disallow_instantiation(self, type(panel))
 
     @requires_curses_func('is_term_resized')
     def test_is_term_resized(self):

Lib/test/test_dbm_gnu.py

@@ -31,8 +31,7 @@ def tearDown(self):
     def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
         self.g = gdbm.open(filename, 'c')
-        tp = type(self.g)
-        self.assertRaises(TypeError, tp)
+        support.check_disallow_instantiation(self, type(self.g))
 
     def test_key_methods(self):
         self.g = gdbm.open(filename, 'c')

Lib/test/test_embed.py

@@ -1541,9 +1541,7 @@ def test_methods(self):
     def test_disallow_instantiation(self):
         fd = self.get_stdout_fd()
         printer = self.create_printer(fd)
-        PyStdPrinter_Type = type(printer)
-        with self.assertRaises(TypeError):
-            PyStdPrinter_Type(fd)
+        support.check_disallow_instantiation(self, type(printer))
 
 
 if __name__ == "__main__":

Lib/test/test_functools.py

@@ -951,8 +951,9 @@ class TestCmpToKeyC(TestCmpToKey, unittest.TestCase):
     @support.cpython_only
     def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
-        tp = type(c_functools.cmp_to_key(None))
-        self.assertRaises(TypeError, tp)
+        support.check_disallow_instantiation(
+            self, type(c_functools.cmp_to_key(None))
+        )
 
 
 class TestCmpToKeyPy(TestCmpToKey, unittest.TestCase):

Lib/test/test_hashlib.py

@@ -915,20 +915,13 @@ def test_disallow_instantiation(self):
                 except ValueError:
                     continue
                 with self.subTest(constructor=constructor):
-                    hash_type = type(h)
-                    self.assertRaises(TypeError, hash_type)
+                    support.check_disallow_instantiation(self, type(h))
 
     @unittest.skipUnless(HASH is not None, 'need _hashlib')
-    def test_hash_disallow_instanciation(self):
+    def test_hash_disallow_instantiation(self):
         # internal types like _hashlib.HASH are not constructable
-        with self.assertRaisesRegex(
-            TypeError, "cannot create '_hashlib.HASH' instance"
-        ):
-            HASH()
-        with self.assertRaisesRegex(
-            TypeError, "cannot create '_hashlib.HASHXOF' instance"
-        ):
-            HASHXOF()
+        support.check_disallow_instantiation(self, HASH)
+        support.check_disallow_instantiation(self, HASHXOF)
 
     def test_readonly_types(self):
         for algorithm, constructors in self.constructors_to_test.items():

Lib/test/test_hmac.py

@@ -6,7 +6,7 @@
 import unittest.mock
 import warnings
 
-from test.support import hashlib_helper
+from test.support import hashlib_helper, check_disallow_instantiation
 
 from _operator import _compare_digest as operator_compare_digest
 
@@ -439,11 +439,7 @@ def test_withmodule(self):
     @unittest.skipUnless(C_HMAC is not None, 'need _hashlib')
     def test_internal_types(self):
         # internal types like _hashlib.C_HMAC are not constructable
-        with self.assertRaisesRegex(
-            TypeError, "cannot create '_hashlib.HMAC' instance"
-        ):
-            C_HMAC()
-
+        check_disallow_instantiation(self, C_HMAC)
         with self.assertRaisesRegex(TypeError, "immutable type"):
             C_HMAC.value = None
 

Lib/test/test_re.py

@@ -1,5 +1,6 @@
 from test.support import (gc_collect, bigmemtest, _2G,
-                          cpython_only, captured_stdout)
+                          cpython_only, captured_stdout,
+                          check_disallow_instantiation)
 import locale
 import re
 import sre_compile
@@ -2218,11 +2219,10 @@ def test_signedness(self):
     @cpython_only
     def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
-        self.assertRaises(TypeError, re.Match)
-        self.assertRaises(TypeError, re.Pattern)
+        check_disallow_instantiation(self, re.Match)
+        check_disallow_instantiation(self, re.Pattern)
         pat = re.compile("")
-        tp = type(pat.scanner(""))
-        self.assertRaises(TypeError, tp)
+        check_disallow_instantiation(self, type(pat.scanner("")))
 
 
 class ExternalTests(unittest.TestCase):

Lib/test/test_select.py

@@ -88,12 +88,10 @@ def fileno(self):
         self.assertEqual(select.select([], a, []), ([], a[:5], []))
 
     def test_disallow_instantiation(self):
-        tp = type(select.poll())
-        self.assertRaises(TypeError, tp)
+        support.check_disallow_instantiation(self, type(select.poll()))
 
         if hasattr(select, 'devpoll'):
-            tp = type(select.devpoll())
-            self.assertRaises(TypeError, tp)
+            support.check_disallow_instantiation(self, type(select.devpoll()))
 
 def tearDownModule():
     support.reap_children()