mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-15 11:22:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

gh-71339: Use new assertion methods in test_typing (GH-128825)

Browse source
This commit is contained in:
Serhiy Storchaka 2025-01-14 15:19:32 +02:00 • committed by GitHub
parent 75bd42c737
commit 859db49029
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 51 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

103
Lib/test/test_typing.py
View file

@ -115,18 +115,18 @@ class AnyTests(BaseTestCase):
def test_can_subclass(self): def test_can_subclass(self):
class Mock(Any): pass class Mock(Any): pass
self.assertTrue(issubclass(Mock, Any)) self.assertIsSubclass(Mock, Any)
self.assertIsInstance(Mock(), Mock) self.assertIsInstance(Mock(), Mock)
class Something: pass class Something: pass
self.assertFalse(issubclass(Something, Any)) self.assertNotIsSubclass(Something, Any)
self.assertNotIsInstance(Something(), Mock) self.assertNotIsInstance(Something(), Mock)
class MockSomething(Something, Mock): pass class MockSomething(Something, Mock): pass
self.assertTrue(issubclass(MockSomething, Any)) self.assertIsSubclass(MockSomething, Any)
self.assertTrue(issubclass(MockSomething, MockSomething)) self.assertIsSubclass(MockSomething, MockSomething)
self.assertTrue(issubclass(MockSomething, Something)) self.assertIsSubclass(MockSomething, Something)
self.assertTrue(issubclass(MockSomething, Mock)) self.assertIsSubclass(MockSomething, Mock)
ms = MockSomething() ms = MockSomething()
self.assertIsInstance(ms, MockSomething) self.assertIsInstance(ms, MockSomething)
self.assertIsInstance(ms, Something) self.assertIsInstance(ms, Something)
@ -1997,11 +1997,11 @@ class UnionTests(BaseTestCase):
self.assertNotEqual(u, Union) self.assertNotEqual(u, Union)
def test_union_isinstance(self): def test_union_isinstance(self):
self.assertTrue(isinstance(42, Union[int, str])) self.assertIsInstance(42, Union[int, str])
self.assertTrue(isinstance('abc', Union[int, str])) self.assertIsInstance('abc', Union[int, str])
self.assertFalse(isinstance(3.14, Union[int, str])) self.assertNotIsInstance(3.14, Union[int, str])
self.assertTrue(isinstance(42, Union[int, list[int]])) self.assertIsInstance(42, Union[int, list[int]])
self.assertTrue(isinstance(42, Union[int, Any])) self.assertIsInstance(42, Union[int, Any])
def test_union_isinstance_type_error(self): def test_union_isinstance_type_error(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
@ -2018,9 +2018,9 @@ class UnionTests(BaseTestCase):
isinstance(42, Union[Any, str]) isinstance(42, Union[Any, str])
def test_optional_isinstance(self): def test_optional_isinstance(self):
self.assertTrue(isinstance(42, Optional[int])) self.assertIsInstance(42, Optional[int])
self.assertTrue(isinstance(None, Optional[int])) self.assertIsInstance(None, Optional[int])
self.assertFalse(isinstance('abc', Optional[int])) self.assertNotIsInstance('abc', Optional[int])
def test_optional_isinstance_type_error(self): def test_optional_isinstance_type_error(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
@ -2033,14 +2033,14 @@ class UnionTests(BaseTestCase):
isinstance(None, Optional[Any]) isinstance(None, Optional[Any])
def test_union_issubclass(self): def test_union_issubclass(self):
self.assertTrue(issubclass(int, Union[int, str])) self.assertIsSubclass(int, Union[int, str])
self.assertTrue(issubclass(str, Union[int, str])) self.assertIsSubclass(str, Union[int, str])
self.assertFalse(issubclass(float, Union[int, str])) self.assertNotIsSubclass(float, Union[int, str])
self.assertTrue(issubclass(int, Union[int, list[int]])) self.assertIsSubclass(int, Union[int, list[int]])
self.assertTrue(issubclass(int, Union[int, Any])) self.assertIsSubclass(int, Union[int, Any])
self.assertFalse(issubclass(int, Union[str, Any])) self.assertNotIsSubclass(int, Union[str, Any])
self.assertTrue(issubclass(int, Union[Any, int])) self.assertIsSubclass(int, Union[Any, int])
self.assertFalse(issubclass(int, Union[Any, str])) self.assertNotIsSubclass(int, Union[Any, str])
def test_union_issubclass_type_error(self): def test_union_issubclass_type_error(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
@ -2057,12 +2057,12 @@ class UnionTests(BaseTestCase):
issubclass(int, Union[list[int], str]) issubclass(int, Union[list[int], str])
def test_optional_issubclass(self): def test_optional_issubclass(self):
self.assertTrue(issubclass(int, Optional[int])) self.assertIsSubclass(int, Optional[int])
self.assertTrue(issubclass(type(None), Optional[int])) self.assertIsSubclass(type(None), Optional[int])
self.assertFalse(issubclass(str, Optional[int])) self.assertNotIsSubclass(str, Optional[int])
self.assertTrue(issubclass(Any, Optional[Any])) self.assertIsSubclass(Any, Optional[Any])
self.assertTrue(issubclass(type(None), Optional[Any])) self.assertIsSubclass(type(None), Optional[Any])
self.assertFalse(issubclass(int, Optional[Any])) self.assertNotIsSubclass(int, Optional[Any])
def test_optional_issubclass_type_error(self): def test_optional_issubclass_type_error(self):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
@ -4050,8 +4050,8 @@ class ProtocolTests(BaseTestCase):
class P(Protocol[T, S]): pass class P(Protocol[T, S]): pass
self.assertTrue(repr(P[T, S]).endswith('P[~T, ~S]')) self.assertEndsWith(repr(P[T, S]), 'P[~T, ~S]')
self.assertTrue(repr(P[int, str]).endswith('P[int, str]')) self.assertEndsWith(repr(P[int, str]), 'P[int, str]')
def test_generic_protocols_eq(self): def test_generic_protocols_eq(self):
T = TypeVar('T') T = TypeVar('T')
@ -4641,8 +4641,7 @@ class GenericTests(BaseTestCase):
self.assertNotEqual(Z, Y[int]) self.assertNotEqual(Z, Y[int])
self.assertNotEqual(Z, Y[T]) self.assertNotEqual(Z, Y[T])
self.assertTrue(str(Z).endswith( self.assertEndsWith(str(Z), '.C[typing.Tuple[str, int]]')
'.C[typing.Tuple[str, int]]'))
def test_new_repr(self): def test_new_repr(self):
T = TypeVar('T') T = TypeVar('T')
@ -4870,12 +4869,12 @@ class GenericTests(BaseTestCase):
self.assertNotEqual(typing.FrozenSet[A[str]], self.assertNotEqual(typing.FrozenSet[A[str]],
typing.FrozenSet[mod_generics_cache.B.A[str]]) typing.FrozenSet[mod_generics_cache.B.A[str]])
self.assertTrue(repr(Tuple[A[str]]).endswith('<locals>.A[str]]')) self.assertEndsWith(repr(Tuple[A[str]]), '<locals>.A[str]]')
self.assertTrue(repr(Tuple[B.A[str]]).endswith('<locals>.B.A[str]]')) self.assertEndsWith(repr(Tuple[B.A[str]]), '<locals>.B.A[str]]')
self.assertTrue(repr(Tuple[mod_generics_cache.A[str]]) self.assertEndsWith(repr(Tuple[mod_generics_cache.A[str]]),
.endswith('mod_generics_cache.A[str]]')) 'mod_generics_cache.A[str]]')
self.assertTrue(repr(Tuple[mod_generics_cache.B.A[str]]) self.assertEndsWith(repr(Tuple[mod_generics_cache.B.A[str]]),
.endswith('mod_generics_cache.B.A[str]]')) 'mod_generics_cache.B.A[str]]')
def test_extended_generic_rules_eq(self): def test_extended_generic_rules_eq(self):
T = TypeVar('T') T = TypeVar('T')
@ -5817,7 +5816,7 @@ class FinalDecoratorTests(BaseTestCase):
@Wrapper @Wrapper
def wrapped(): ... def wrapped(): ...
self.assertIsInstance(wrapped, Wrapper) self.assertIsInstance(wrapped, Wrapper)
self.assertIs(False, hasattr(wrapped, "__final__")) self.assertNotHasAttr(wrapped, "__final__")
class Meta(type): class Meta(type):
@property @property
@ -5829,7 +5828,7 @@ class FinalDecoratorTests(BaseTestCase):
# Builtin classes throw TypeError if you try to set an # Builtin classes throw TypeError if you try to set an
# attribute. # attribute.
final(int) final(int)
self.assertIs(False, hasattr(int, "__final__")) self.assertNotHasAttr(int, "__final__")
# Make sure it works with common builtin decorators # Make sure it works with common builtin decorators
class Methods: class Methods:
@ -5910,19 +5909,19 @@ class OverrideDecoratorTests(BaseTestCase):
self.assertEqual(Derived.class_method_good_order(), 42) self.assertEqual(Derived.class_method_good_order(), 42)
self.assertIs(True, Derived.class_method_good_order.__override__) self.assertIs(True, Derived.class_method_good_order.__override__)
self.assertEqual(Derived.class_method_bad_order(), 42) self.assertEqual(Derived.class_method_bad_order(), 42)
self.assertIs(False, hasattr(Derived.class_method_bad_order, "__override__")) self.assertNotHasAttr(Derived.class_method_bad_order, "__override__")
self.assertEqual(Derived.static_method_good_order(), 42) self.assertEqual(Derived.static_method_good_order(), 42)
self.assertIs(True, Derived.static_method_good_order.__override__) self.assertIs(True, Derived.static_method_good_order.__override__)
self.assertEqual(Derived.static_method_bad_order(), 42) self.assertEqual(Derived.static_method_bad_order(), 42)
self.assertIs(False, hasattr(Derived.static_method_bad_order, "__override__")) self.assertNotHasAttr(Derived.static_method_bad_order, "__override__")
# Base object is not changed: # Base object is not changed:
self.assertIs(False, hasattr(Base.normal_method, "__override__")) self.assertNotHasAttr(Base.normal_method, "__override__")
self.assertIs(False, hasattr(Base.class_method_good_order, "__override__")) self.assertNotHasAttr(Base.class_method_good_order, "__override__")
self.assertIs(False, hasattr(Base.class_method_bad_order, "__override__")) self.assertNotHasAttr(Base.class_method_bad_order, "__override__")
self.assertIs(False, hasattr(Base.static_method_good_order, "__override__")) self.assertNotHasAttr(Base.static_method_good_order, "__override__")
self.assertIs(False, hasattr(Base.static_method_bad_order, "__override__")) self.assertNotHasAttr(Base.static_method_bad_order, "__override__")
def test_property(self): def test_property(self):
class Base: class Base:
@ -5947,8 +5946,8 @@ class OverrideDecoratorTests(BaseTestCase):
self.assertEqual(instance.correct, 2) self.assertEqual(instance.correct, 2)
self.assertTrue(Child.correct.fget.__override__) self.assertTrue(Child.correct.fget.__override__)
self.assertEqual(instance.wrong, 2) self.assertEqual(instance.wrong, 2)
self.assertFalse(hasattr(Child.wrong, "__override__")) self.assertNotHasAttr(Child.wrong, "__override__")
self.assertFalse(hasattr(Child.wrong.fset, "__override__")) self.assertNotHasAttr(Child.wrong.fset, "__override__")
def test_silent_failure(self): def test_silent_failure(self):
class CustomProp: class CustomProp:
@ -5965,7 +5964,7 @@ class OverrideDecoratorTests(BaseTestCase):
return 1 return 1
self.assertEqual(WithOverride.some, 1) self.assertEqual(WithOverride.some, 1)
self.assertFalse(hasattr(WithOverride.some, "__override__")) self.assertNotHasAttr(WithOverride.some, "__override__")
def test_multiple_decorators(self): def test_multiple_decorators(self):
def with_wraps(f): # similar to `lru_cache` definition def with_wraps(f): # similar to `lru_cache` definition
@ -10474,7 +10473,7 @@ class SpecialAttrsTests(BaseTestCase):
# to the variable name to which it is assigned". Thus, providing # to the variable name to which it is assigned". Thus, providing
# __qualname__ is unnecessary. # __qualname__ is unnecessary.
self.assertEqual(SpecialAttrsT.__name__, 'SpecialAttrsT') self.assertEqual(SpecialAttrsT.__name__, 'SpecialAttrsT')
self.assertFalse(hasattr(SpecialAttrsT, '__qualname__')) self.assertNotHasAttr(SpecialAttrsT, '__qualname__')
self.assertEqual(SpecialAttrsT.__module__, __name__) self.assertEqual(SpecialAttrsT.__module__, __name__)
# Module-level type variables are picklable. # Module-level type variables are picklable.
for proto in range(pickle.HIGHEST_PROTOCOL + 1): for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@ -10483,7 +10482,7 @@ class SpecialAttrsTests(BaseTestCase):
self.assertIs(SpecialAttrsT, loaded) self.assertIs(SpecialAttrsT, loaded)
self.assertEqual(SpecialAttrsP.__name__, 'SpecialAttrsP') self.assertEqual(SpecialAttrsP.__name__, 'SpecialAttrsP')
self.assertFalse(hasattr(SpecialAttrsP, '__qualname__')) self.assertNotHasAttr(SpecialAttrsP, '__qualname__')
self.assertEqual(SpecialAttrsP.__module__, __name__) self.assertEqual(SpecialAttrsP.__module__, __name__)
# Module-level ParamSpecs are picklable. # Module-level ParamSpecs are picklable.
for proto in range(pickle.HIGHEST_PROTOCOL + 1): for proto in range(pickle.HIGHEST_PROTOCOL + 1):