def METHOD_NAME(self):
    for abstractthing in [abc.abstractmethod, abc.abstractproperty]:
        class C:
            __metaclass__ = abc.ABCMeta
            @abstractthing
            def foo(self): pass  # abstract
            def bar(self): pass  # concrete
        self.assertEqual(C.__abstractmethods__, set(["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__, set(["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__, set(["bar"]))
        self.assertRaises(TypeError, F)  # because bar is abstract now
        self.assertTrue(isabstract(F))