gh-71339: Use new assertion methods in test_abc (GH-128826)

diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index 5ce57cc209ea85c63c04e860cc0919cfa917f60e..e90a8dc617c094a830054c37c0718d8e4e8c581c 100644 (file)
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -20,7 +20,7 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             def foo(self): pass
             self.assertTrue(foo.__isabstractmethod__)
             def bar(self): pass
-            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+            self.assertNotHasAttr(bar, "__isabstractmethod__")
 
             class C(metaclass=abc_ABCMeta):
                 @abc.abstractproperty
@@ -89,7 +89,7 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             def foo(self): pass
             self.assertTrue(foo.__isabstractmethod__)
             def bar(self): pass
-            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+            self.assertNotHasAttr(bar, "__isabstractmethod__")
 
         def test_abstractproperty_basics(self):
             @property
@@ -276,21 +276,21 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             class B(object):
                 pass
             b = B()
-            self.assertFalse(issubclass(B, A))
-            self.assertFalse(issubclass(B, (A,)))
+            self.assertNotIsSubclass(B, A)
+            self.assertNotIsSubclass(B, (A,))
             self.assertNotIsInstance(b, A)
             self.assertNotIsInstance(b, (A,))
             B1 = A.register(B)
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             self.assertIsInstance(b, A)
             self.assertIsInstance(b, (A,))
             self.assertIs(B1, B)
             class C(B):
                 pass
             c = C()
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
             self.assertIsInstance(c, A)
             self.assertIsInstance(c, (A,))
 
@@ -301,16 +301,16 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             class B(object):
                 pass
             b = B()
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             self.assertIsInstance(b, A)
             self.assertIsInstance(b, (A,))
             @A.register
             class C(B):
                 pass
             c = C()
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
             self.assertIsInstance(c, A)
             self.assertIsInstance(c, (A,))
             self.assertIs(C, A.register(C))
@@ -321,14 +321,14 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             class B:
                 pass
             b = B()
-            self.assertFalse(isinstance(b, A))
-            self.assertFalse(isinstance(b, (A,)))
+            self.assertNotIsInstance(b, A)
+            self.assertNotIsInstance(b, (A,))
             token_old = abc_get_cache_token()
             A.register(B)
             token_new = abc_get_cache_token()
             self.assertGreater(token_new, token_old)
-            self.assertTrue(isinstance(b, A))
-            self.assertTrue(isinstance(b, (A,)))
+            self.assertIsInstance(b, A)
+            self.assertIsInstance(b, (A,))
 
         def test_registration_builtins(self):
             class A(metaclass=abc_ABCMeta):
@@ -336,18 +336,18 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             A.register(int)
             self.assertIsInstance(42, A)
             self.assertIsInstance(42, (A,))
-            self.assertTrue(issubclass(int, A))
-            self.assertTrue(issubclass(int, (A,)))
+            self.assertIsSubclass(int, A)
+            self.assertIsSubclass(int, (A,))
             class B(A):
                 pass
             B.register(str)
             class C(str): pass
             self.assertIsInstance("", A)
             self.assertIsInstance("", (A,))
-            self.assertTrue(issubclass(str, A))
-            self.assertTrue(issubclass(str, (A,)))
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(str, A)
+            self.assertIsSubclass(str, (A,))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
 
         def test_registration_edge_cases(self):
             class A(metaclass=abc_ABCMeta):
@@ -375,39 +375,39 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
         def test_registration_transitiveness(self):
             class A(metaclass=abc_ABCMeta):
                 pass
-            self.assertTrue(issubclass(A, A))
-            self.assertTrue(issubclass(A, (A,)))
+            self.assertIsSubclass(A, A)
+            self.assertIsSubclass(A, (A,))
             class B(metaclass=abc_ABCMeta):
                 pass
-            self.assertFalse(issubclass(A, B))
-            self.assertFalse(issubclass(A, (B,)))
-            self.assertFalse(issubclass(B, A))
-            self.assertFalse(issubclass(B, (A,)))
+            self.assertNotIsSubclass(A, B)
+            self.assertNotIsSubclass(A, (B,))
+            self.assertNotIsSubclass(B, A)
+            self.assertNotIsSubclass(B, (A,))
             class C(metaclass=abc_ABCMeta):
                 pass
             A.register(B)
             class B1(B):
                 pass
-            self.assertTrue(issubclass(B1, A))
-            self.assertTrue(issubclass(B1, (A,)))
+            self.assertIsSubclass(B1, A)
+            self.assertIsSubclass(B1, (A,))
             class C1(C):
                 pass
             B1.register(C1)
-            self.assertFalse(issubclass(C, B))
-            self.assertFalse(issubclass(C, (B,)))
-            self.assertFalse(issubclass(C, B1))
-            self.assertFalse(issubclass(C, (B1,)))
-            self.assertTrue(issubclass(C1, A))
-            self.assertTrue(issubclass(C1, (A,)))
-            self.assertTrue(issubclass(C1, B))
-            self.assertTrue(issubclass(C1, (B,)))
-            self.assertTrue(issubclass(C1, B1))
-            self.assertTrue(issubclass(C1, (B1,)))
+            self.assertNotIsSubclass(C, B)
+            self.assertNotIsSubclass(C, (B,))
+            self.assertNotIsSubclass(C, B1)
+            self.assertNotIsSubclass(C, (B1,))
+            self.assertIsSubclass(C1, A)
+            self.assertIsSubclass(C1, (A,))
+            self.assertIsSubclass(C1, B)
+            self.assertIsSubclass(C1, (B,))
+            self.assertIsSubclass(C1, B1)
+            self.assertIsSubclass(C1, (B1,))
             C1.register(int)
             class MyInt(int):
                 pass
-            self.assertTrue(issubclass(MyInt, A))
-            self.assertTrue(issubclass(MyInt, (A,)))
+            self.assertIsSubclass(MyInt, A)
+            self.assertIsSubclass(MyInt, (A,))
             self.assertIsInstance(42, A)
             self.assertIsInstance(42, (A,))
 
@@ -467,16 +467,16 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
                     if cls is A:
                         return 'foo' in C.__dict__
                     return NotImplemented
-            self.assertFalse(issubclass(A, A))
-            self.assertFalse(issubclass(A, (A,)))
+            self.assertNotIsSubclass(A, A)
+            self.assertNotIsSubclass(A, (A,))
             class B:
                 foo = 42
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             class C:
                 spam = 42
-            self.assertFalse(issubclass(C, A))
-            self.assertFalse(issubclass(C, (A,)))
+            self.assertNotIsSubclass(C, A)
+            self.assertNotIsSubclass(C, (A,))
 
         def test_all_new_methods_are_called(self):
             class A(metaclass=abc_ABCMeta):
@@ -493,7 +493,7 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             self.assertEqual(B.counter, 1)
 
         def test_ABC_has___slots__(self):
-            self.assertTrue(hasattr(abc.ABC, '__slots__'))
+            self.assertHasAttr(abc.ABC, '__slots__')
 
         def test_tricky_new_works(self):
             def with_metaclass(meta, *bases):
@@ -515,7 +515,7 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
 
             del A.foo
             self.assertEqual(A.__abstractmethods__, {'foo'})
-            self.assertFalse(hasattr(A, 'foo'))
+            self.assertNotHasAttr(A, 'foo')
 
             abc.update_abstractmethods(A)
 
@@ -588,7 +588,7 @@ def test_factory(abc_ABCMeta, abc_get_cache_token):
             A.foo = updated_foo
             abc.update_abstractmethods(A)
             A()
-            self.assertFalse(hasattr(A, '__abstractmethods__'))
+            self.assertNotHasAttr(A, '__abstractmethods__')
 
         def test_update_del_implementation(self):
             class A(metaclass=abc_ABCMeta):