Using appropriate checks in tests

Lib/test/test_abc.py

 # Copyright 2007 Google, Inc. All Rights Reserved.
 # Licensed to PSF under a Contributor Agreement.
 
 """Unit tests for abc.py."""
 
 import unittest
 from test import support
 
 import abc
 from inspect import isabstract
@@ skipping 39 matching lines @@
     def test_abstractstaticmethod_basics(self):
         @abc.abstractstaticmethod
         def foo(): pass
         self.assertTrue(foo.__isabstractmethod__)
         @staticmethod
         def bar(): pass
         self.assertFalse(getattr(bar, "__isabstractmethod__", False))
 
         class C(metaclass=abc.ABCMeta):
             @abc.abstractstaticmethod
+            def foo(): return 3
+        self.assertRaises(TypeError, C)
+        class D(C):
+            @staticmethod
+            def foo(): return 4
+        self.assertEqual(D.foo(), 4)
+        self.assertEqual(D().foo(), 4)
+
+
+class TestABC(unittest.TestCase):
+
+    def test_ABC_helper(self):
+        # create an ABC using the helper class and perform basic checks
+        class C(abc.ABC):
+            @classmethod
+            @abc.abstractmethod
+            def foo(cls): return cls.__name__
+        self.assertEqual(type(C), abc.ABCMeta)
+        self.assertRaises(TypeError, C)
+        class D(C):
+            @classmethod
+            def foo(cls): return super().foo()
+        self.assertEqual(D.foo(), 'D')
+
+    def test_abstractmethod_basics(self):
+        @abc.abstractmethod
+        def foo(self): pass
+        self.assertTrue(foo.__isabstractmethod__)
+        def bar(self): pass
+        self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+
+    def test_abstractproperty_basics(self):
+        @property
+        @abc.abstractmethod
+        def foo(self): pass
+        self.assertTrue(foo.__isabstractmethod__)
+        def bar(self): pass
+        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+        class C(metaclass=abc.ABCMeta):
+            @property
+            @abc.abstractmethod
+            def foo(self): return 3
+        self.assertRaises(TypeError, C)
+        class D(C):
+            @C.foo.getter
+            def foo(self): return super().foo
+        self.assertEqual(D().foo, 3)
+
+    def test_abstractclassmethod_basics(self):
+        @classmethod
+        @abc.abstractmethod
+        def foo(cls): pass
+        self.assertTrue(foo.__isabstractmethod__)
+        @classmethod
+        def bar(cls): pass
+        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+        class C(metaclass=abc.ABCMeta):
+            @classmethod
+            @abc.abstractmethod
+            def foo(cls): return cls.__name__
+        self.assertRaises(TypeError, C)
+        class D(C):
+            @classmethod
+            def foo(cls): return super().foo()
+        self.assertEqual(D.foo(), 'D')
+        self.assertEqual(D().foo(), 'D')
+
+    def test_abstractstaticmethod_basics(self):
+        @staticmethod
+        @abc.abstractmethod
+        def foo(): pass
+        self.assertTrue(foo.__isabstractmethod__)
+        @staticmethod
+        def bar(): pass
+        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+        class C(metaclass=abc.ABCMeta):
+            @staticmethod
+            @abc.abstractmethod
             def foo(): return 3
         self.assertRaises(TypeError, C)
         class D(C):
             @staticmethod
             def foo(): return 4
         self.assertEqual(D.foo(), 4)
         self.assertEqual(D().foo(), 4)
 
     def test_abstractmethod_integration(self):
         for abstractthing in [abc.abstractmethod, abc.abstractproperty,
@@ skipping 16 matching lines @@
             self.assertEqual(E.__abstractmethods__, set())
             E()  # now foo is concrete, too
             self.assertFalse(isabstract(E))
             class F(E):
                 @abstractthing
                 def bar(self): pass  # abstract override of concrete
             self.assertEqual(F.__abstractmethods__, {"bar"})
             self.assertRaises(TypeError, F)  # because bar is abstract now
             self.assertTrue(isabstract(F))
 
-
-class TestABC(unittest.TestCase):
-
-    def test_abstractmethod_basics(self):
-        @abc.abstractmethod
-        def foo(self): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        def bar(self): pass
-        self.assertFalse(hasattr(bar, "__isabstractmethod__"))
-
-    def test_abstractproperty_basics(self):
-        @property
-        @abc.abstractmethod
-        def foo(self): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        def bar(self): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @property
-            @abc.abstractmethod
-            def foo(self): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @C.foo.getter
-            def foo(self): return super().foo
-        self.assertEqual(D().foo, 3)
-
-    def test_abstractclassmethod_basics(self):
-        @classmethod
-        @abc.abstractmethod
-        def foo(cls): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @classmethod
-        def bar(cls): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @classmethod
-            @abc.abstractmethod
-            def foo(cls): return cls.__name__
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @classmethod
-            def foo(cls): return super().foo()
-        self.assertEqual(D.foo(), 'D')
-        self.assertEqual(D().foo(), 'D')
-
-    def test_abstractstaticmethod_basics(self):
-        @staticmethod
-        @abc.abstractmethod
-        def foo(): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @staticmethod
-        def bar(): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @staticmethod
-            @abc.abstractmethod
-            def foo(): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @staticmethod
-            def foo(): return 4
-        self.assertEqual(D.foo(), 4)
-        self.assertEqual(D().foo(), 4)
-
-    def test_abstractmethod_integration(self):
-        for abstractthing in [abc.abstractmethod, abc.abstractproperty,
-                              abc.abstractclassmethod,
-                              abc.abstractstaticmethod]:
-            class C(metaclass=abc.ABCMeta):
-                @abstractthing
-                def foo(self): pass  # abstract
-                def bar(self): pass  # concrete
-            self.assertEqual(C.__abstractmethods__, {"foo"})
-            self.assertRaises(TypeError, C)  # because foo is abstract
-            self.assertTrue(isabstract(C))
-            class D(C):
-                def bar(self): pass  # concrete override of concrete
-            self.assertEqual(D.__abstractmethods__, {"foo"})
-            self.assertRaises(TypeError, D)  # because foo is still abstract
-            self.assertTrue(isabstract(D))
-            class E(D):
-                def foo(self): pass
-            self.assertEqual(E.__abstractmethods__, set())
-            E()  # now foo is concrete, too
-            self.assertFalse(isabstract(E))
-            class F(E):
-                @abstractthing
-                def bar(self): pass  # abstract override of concrete
-            self.assertEqual(F.__abstractmethods__, {"bar"})
-            self.assertRaises(TypeError, F)  # because bar is abstract now
-            self.assertTrue(isabstract(F))
-
     def test_descriptors_with_abstractmethod(self):
         class C(metaclass=abc.ABCMeta):
             @property
             @abc.abstractmethod
             def foo(self): return 3
             @foo.setter
             @abc.abstractmethod
             def foo(self, val): pass
         self.assertRaises(TypeError, C)
         class D(C):
@@ skipping 107 matching lines @@
         self.assertIs(C, A.register(C))
 
     def test_isinstance_invalidation(self):
         class A(metaclass=abc.ABCMeta):
             pass
         class B:
             pass
         b = B()
         self.assertNotIsInstance(b, A)
         self.assertNotIsInstance(b, (A,))
+        token_old = abc.get_cache_token()
         A.register(B)
+        token_new = abc.get_cache_token()
+        self.assertNotEqual(token_old, token_new)
         self.assertIsInstance(b, A)
         self.assertIsInstance(b, (A,))
 
     def test_registration_builtins(self):
         class A(metaclass=abc.ABCMeta):
             pass
         A.register(int)
         self.assertIsInstance(42, A)
         self.assertIsInstance(42, (A,))
         self.assertTrue(issubclass(int, A))
@@ skipping 79 matching lines @@
             def __new__(cls):
                 B.counter += 1
                 return super().__new__(cls)
         class C(A, B):
             pass
         self.assertEqual(B.counter, 0)
         C()
         self.assertEqual(B.counter, 1)
 
 
-def test_main():
-    support.run_unittest(TestABC)
-
-
 if __name__ == "__main__":
     unittest.main()