Lines Matching refs:self
18 def test_abstractproperty_basics(self):
20 def foo(self): pass
21 self.assertTrue(foo.__isabstractmethod__)
22 def bar(self): pass
23 self.assertFalse(hasattr(bar, "__isabstractmethod__"))
27 def foo(self): return 3
28 self.assertRaises(TypeError, C)
31 def foo(self): return super().foo
32 self.assertEqual(D().foo, 3)
33 self.assertFalse(getattr(D.foo, "__isabstractmethod__", False))
35 def test_abstractclassmethod_basics(self):
38 self.assertTrue(foo.__isabstractmethod__)
41 self.assertFalse(getattr(bar, "__isabstractmethod__", False))
46 self.assertRaises(TypeError, C)
50 self.assertEqual(D.foo(), 'D')
51 self.assertEqual(D().foo(), 'D')
53 def test_abstractstaticmethod_basics(self):
56 self.assertTrue(foo.__isabstractmethod__)
59 self.assertFalse(getattr(bar, "__isabstractmethod__", False))
64 self.assertRaises(TypeError, C)
68 self.assertEqual(D.foo(), 4)
69 self.assertEqual(D().foo(), 4)
74 def test_ABC_helper(self):
80 self.assertEqual(type(C), abc.ABCMeta)
81 self.assertRaises(TypeError, C)
85 self.assertEqual(D.foo(), 'D')
87 def test_abstractmethod_basics(self):
89 def foo(self): pass
90 self.assertTrue(foo.__isabstractmethod__)
91 def bar(self): pass
92 self.assertFalse(hasattr(bar, "__isabstractmethod__"))
94 def test_abstractproperty_basics(self):
97 def foo(self): pass
98 self.assertTrue(foo.__isabstractmethod__)
99 def bar(self): pass
100 self.assertFalse(getattr(bar, "__isabstractmethod__", False))
105 def foo(self): return 3
106 self.assertRaises(TypeError, C)
109 def foo(self): return super().foo
110 self.assertEqual(D().foo, 3)
112 def test_abstractclassmethod_basics(self):
116 self.assertTrue(foo.__isabstractmethod__)
119 self.assertFalse(getattr(bar, "__isabstractmethod__", False))
125 self.assertRaises(TypeError, C)
129 self.assertEqual(D.foo(), 'D')
130 self.assertEqual(D().foo(), 'D')
132 def test_abstractstaticmethod_basics(self):
136 self.assertTrue(foo.__isabstractmethod__)
139 self.assertFalse(getattr(bar, "__isabstractmethod__", False))
145 self.assertRaises(TypeError, C)
149 self.assertEqual(D.foo(), 4)
150 self.assertEqual(D().foo(), 4)
152 def test_object_new_with_one_abstractmethod(self):
155 def method_one(self):
158 self.assertRaisesRegex(TypeError, msg, C)
160 def test_object_new_with_many_abstractmethods(self):
163 def method_one(self):
166 def method_two(self):
169 self.assertRaisesRegex(TypeError, msg, C)
171 def test_abstractmethod_integration(self):
177 def foo(self): pass # abstract
178 def bar(self): pass # concrete
179 self.assertEqual(C.__abstractmethods__, {"foo"})
180 self.assertRaises(TypeError, C) # because foo is abstract
181 self.assertTrue(isabstract(C))
183 def bar(self): pass # concrete override of concrete
184 self.assertEqual(D.__abstractmethods__, {"foo"})
185 self.assertRaises(TypeError, D) # because foo is still abstract
186 self.assertTrue(isabstract(D))
188 def foo(self): pass
189 self.assertEqual(E.__abstractmethods__, set())
191 self.assertFalse(isabstract(E))
194 def bar(self): pass # abstract override of concrete
195 self.assertEqual(F.__abstractmethods__, {"bar"})
196 self.assertRaises(TypeError, F) # because bar is abstract now
197 self.assertTrue(isabstract(F))
199 def test_descriptors_with_abstractmethod(self):
203 def foo(self): return 3
206 def foo(self, val): pass
207 self.assertRaises(TypeError, C)
210 def foo(self): return super().foo
211 self.assertRaises(TypeError, D)
214 def foo(self, val): pass
215 self.assertEqual(E().foo, 3)
219 def __bool__(self):
222 with self.assertRaises(ValueError):
224 def bar(self):
230 def test_customdescriptors_with_abstractmethod(self):
232 def __init__(self, fget, fset=None):
233 self._fget = fget
234 self._fset = fset
235 def getter(self, callable):
236 return Descriptor(callable, self._fget)
237 def setter(self, callable):
238 return Descriptor(self._fget, callable)
240 def __isabstractmethod__(self):
241 return (getattr(self._fget, '__isabstractmethod__', False)
242 or getattr(self._fset, '__isabstractmethod__', False))
246 def foo(self): return 3
249 def foo(self, val): pass
250 self.assertRaises(TypeError, C)
253 def foo(self): return super().foo
254 self.assertRaises(TypeError, D)
257 def foo(self, val): pass
258 self.assertFalse(E.foo.__isabstractmethod__)
260 def test_metaclass_abc(self):
264 def x(self):
266 self.assertEqual(A.__abstractmethods__, {"x"})
268 def x(self):
273 def test_registration_basics(self):
279 self.assertFalse(issubclass(B, A))
280 self.assertFalse(issubclass(B, (A,)))
281 self.assertNotIsInstance(b, A)
282 self.assertNotIsInstance(b, (A,))
284 self.assertTrue(issubclass(B, A))
285 self.assertTrue(issubclass(B, (A,)))
286 self.assertIsInstance(b, A)
287 self.assertIsInstance(b, (A,))
288 self.assertIs(B1, B)
292 self.assertTrue(issubclass(C, A))
293 self.assertTrue(issubclass(C, (A,)))
294 self.assertIsInstance(c, A)
295 self.assertIsInstance(c, (A,))
297 def test_register_as_class_deco(self):
304 self.assertTrue(issubclass(B, A))
305 self.assertTrue(issubclass(B, (A,)))
306 self.assertIsInstance(b, A)
307 self.assertIsInstance(b, (A,))
312 self.assertTrue(issubclass(C, A))
313 self.assertTrue(issubclass(C, (A,)))
314 self.assertIsInstance(c, A)
315 self.assertIsInstance(c, (A,))
316 self.assertIs(C, A.register(C))
318 def test_isinstance_invalidation(self):
324 self.assertFalse(isinstance(b, A))
325 self.assertFalse(isinstance(b, (A,)))
329 self.assertGreater(token_new, token_old)
330 self.assertTrue(isinstance(b, A))
331 self.assertTrue(isinstance(b, (A,)))
333 def test_registration_builtins(self):
337 self.assertIsInstance(42, A)
338 self.assertIsInstance(42, (A,))
339 self.assertTrue(issubclass(int, A))
340 self.assertTrue(issubclass(int, (A,)))
345 self.assertIsInstance("", A)
346 self.assertIsInstance("", (A,))
347 self.assertTrue(issubclass(str, A))
348 self.assertTrue(issubclass(str, (A,)))
349 self.assertTrue(issubclass(C, A))
350 self.assertTrue(issubclass(C, (A,)))
352 def test_registration_edge_cases(self):
358 self.assertRaises(RuntimeError, A1.register, A) # cycles not allowed
366 self.assertRaises(RuntimeError, C.register, A) # cycles not allowed
369 def test_register_non_class(self):
372 self.assertRaisesRegex(TypeError, "Can only register classes",
375 def test_registration_transitiveness(self):
378 self.assertTrue(issubclass(A, A))
379 self.assertTrue(issubclass(A, (A,)))
382 self.assertFalse(issubclass(A, B))
383 self.assertFalse(issubclass(A, (B,)))
384 self.assertFalse(issubclass(B, A))
385 self.assertFalse(issubclass(B, (A,)))
391 self.assertTrue(issubclass(B1, A))
392 self.assertTrue(issubclass(B1, (A,)))
396 self.assertFalse(issubclass(C, B))
397 self.assertFalse(issubclass(C, (B,)))
398 self.assertFalse(issubclass(C, B1))
399 self.assertFalse(issubclass(C, (B1,)))
400 self.assertTrue(issubclass(C1, A))
401 self.assertTrue(issubclass(C1, (A,)))
402 self.assertTrue(issubclass(C1, B))
403 self.assertTrue(issubclass(C1, (B,)))
404 self.assertTrue(issubclass(C1, B1))
405 self.assertTrue(issubclass(C1, (B1,)))
409 self.assertTrue(issubclass(MyInt, A))
410 self.assertTrue(issubclass(MyInt, (A,)))
411 self.assertIsInstance(42, A)
412 self.assertIsInstance(42, (A,))
414 def test_issubclass_bad_arguments(self):
418 with self.assertRaises(TypeError):
421 with self.assertRaises(TypeError):
429 with self.assertRaises(TypeError):
445 with self.subTest(i=i):
446 with self.assertRaises(TypeError):
459 with self.assertRaisesRegex(Exception, exc_msg):
462 def test_subclasshook(self):
469 self.assertFalse(issubclass(A, A))
470 self.assertFalse(issubclass(A, (A,)))
473 self.assertTrue(issubclass(B, A))
474 self.assertTrue(issubclass(B, (A,)))
477 self.assertFalse(issubclass(C, A))
478 self.assertFalse(issubclass(C, (A,)))
480 def test_all_new_methods_are_called(self):
490 self.assertEqual(B.counter, 0)
492 self.assertEqual(B.counter, 1)
494 def test_ABC_has___slots__(self):
495 self.assertTrue(hasattr(abc.ABC, '__slots__'))
497 def test_tricky_new_works(self):
507 self.assertEqual(C.__class__, abc_ABCMeta)
509 def test_update_del(self):
512 def foo(self):
516 self.assertEqual(A.__abstractmethods__, {'foo'})
517 self.assertFalse(hasattr(A, 'foo'))
521 self.assertEqual(A.__abstractmethods__, set())
525 def test_update_new_abstractmethods(self):
528 def bar(self):
532 def updated_foo(self):
537 self.assertEqual(A.__abstractmethods__, {'foo', 'bar'})
539 self.assertRaisesRegex(TypeError, msg, A)
541 def test_update_implementation(self):
544 def foo(self):
551 self.assertRaisesRegex(TypeError, msg, B)
552 self.assertEqual(B.__abstractmethods__, {'foo'})
554 B.foo = lambda self: None
559 self.assertEqual(B.__abstractmethods__, set())
561 def test_update_as_decorator(self):
564 def foo(self):
568 cls.foo = lambda self: None
577 self.assertEqual(B.__abstractmethods__, set())
579 def test_update_non_abc(self):
584 def updated_foo(self):
590 self.assertFalse(hasattr(A, '__abstractmethods__'))
592 def test_update_del_implementation(self):
595 def foo(self):
599 def foo(self):
609 self.assertRaisesRegex(TypeError, msg, B)
611 def test_update_layered_implementation(self):
614 def foo(self):
621 def foo(self):
631 self.assertRaisesRegex(TypeError, msg, C)
633 def test_update_multi_inheritance(self):
636 def foo(self):
640 def foo(self):
645 def foo(self):
648 self.assertEqual(C.__abstractmethods__, {'foo'})
654 self.assertEqual(C.__abstractmethods__, set())
660 def test_works_with_init_subclass(self):
670 self.assertEqual(saved_kwargs, dict(x=1, y=2, z=3))
672 def test_positional_only_and_kwonlyargs_with_init_subclass(self):
682 self.assertEqual(saved_kwargs, dict(name="test"))