https://github.com/python/cpython/commit/887f2bcf48eaa13363f9276fdaa9e6b22deaeb65
commit: 887f2bcf48eaa13363f9276fdaa9e6b22deaeb65
branch: main
author: Serhiy Storchaka <[email protected]>
committer: serhiy-storchaka <[email protected]>
date: 2025-01-20T11:16:32+02:00
summary:
gh-71339: Use assertIsSubclass() and assertNotIsSubclass() in test_collections
(GH-128824)
files:
M Lib/test/test_collections.py
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index a24d3e3ea142b7..1e93530398be79 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -742,11 +742,11 @@ def validate_isinstance(self, abc, name):
C = type('C', (object,), {'__hash__': None})
setattr(C, name, stub)
self.assertIsInstance(C(), abc)
- self.assertTrue(issubclass(C, abc))
+ self.assertIsSubclass(C, abc)
C = type('C', (object,), {'__hash__': None})
self.assertNotIsInstance(C(), abc)
- self.assertFalse(issubclass(C, abc))
+ self.assertNotIsSubclass(C, abc)
def validate_comparison(self, instance):
ops = ['lt', 'gt', 'le', 'ge', 'ne', 'or', 'and', 'xor', 'sub']
@@ -812,12 +812,12 @@ def __await__(self):
non_samples = [None, int(), gen(), object()]
for x in non_samples:
self.assertNotIsInstance(x, Awaitable)
- self.assertFalse(issubclass(type(x), Awaitable), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Awaitable)
samples = [Bar(), MinimalCoro()]
for x in samples:
self.assertIsInstance(x, Awaitable)
- self.assertTrue(issubclass(type(x), Awaitable))
+ self.assertIsSubclass(type(x), Awaitable)
c = coro()
# Iterable coroutines (generators with CO_ITERABLE_COROUTINE
@@ -831,8 +831,8 @@ def __await__(self):
class CoroLike: pass
Coroutine.register(CoroLike)
- self.assertTrue(isinstance(CoroLike(), Awaitable))
- self.assertTrue(issubclass(CoroLike, Awaitable))
+ self.assertIsInstance(CoroLike(), Awaitable)
+ self.assertIsSubclass(CoroLike, Awaitable)
CoroLike = None
support.gc_collect() # Kill CoroLike to clean-up ABCMeta cache
@@ -864,12 +864,12 @@ def __await__(self):
non_samples = [None, int(), gen(), object(), Bar()]
for x in non_samples:
self.assertNotIsInstance(x, Coroutine)
- self.assertFalse(issubclass(type(x), Coroutine), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Coroutine)
samples = [MinimalCoro()]
for x in samples:
self.assertIsInstance(x, Awaitable)
- self.assertTrue(issubclass(type(x), Awaitable))
+ self.assertIsSubclass(type(x), Awaitable)
c = coro()
# Iterable coroutines (generators with CO_ITERABLE_COROUTINE
@@ -890,8 +890,8 @@ def close(self):
pass
def __await__(self):
pass
- self.assertTrue(isinstance(CoroLike(), Coroutine))
- self.assertTrue(issubclass(CoroLike, Coroutine))
+ self.assertIsInstance(CoroLike(), Coroutine)
+ self.assertIsSubclass(CoroLike, Coroutine)
class CoroLike:
def send(self, value):
@@ -900,15 +900,15 @@ def close(self):
pass
def __await__(self):
pass
- self.assertFalse(isinstance(CoroLike(), Coroutine))
- self.assertFalse(issubclass(CoroLike, Coroutine))
+ self.assertNotIsInstance(CoroLike(), Coroutine)
+ self.assertNotIsSubclass(CoroLike, Coroutine)
def test_Hashable(self):
# Check some non-hashables
non_samples = [bytearray(), list(), set(), dict()]
for x in non_samples:
self.assertNotIsInstance(x, Hashable)
- self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Hashable)
# Check some hashables
samples = [None,
int(), float(), complex(),
@@ -918,14 +918,14 @@ def test_Hashable(self):
]
for x in samples:
self.assertIsInstance(x, Hashable)
- self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
+ self.assertIsSubclass(type(x), Hashable)
self.assertRaises(TypeError, Hashable)
# Check direct subclassing
class H(Hashable):
def __hash__(self):
return super().__hash__()
self.assertEqual(hash(H()), 0)
- self.assertFalse(issubclass(int, H))
+ self.assertNotIsSubclass(int, H)
self.validate_abstract_methods(Hashable, '__hash__')
self.validate_isinstance(Hashable, '__hash__')
@@ -933,13 +933,13 @@ def test_AsyncIterable(self):
class AI:
def __aiter__(self):
return self
- self.assertTrue(isinstance(AI(), AsyncIterable))
- self.assertTrue(issubclass(AI, AsyncIterable))
+ self.assertIsInstance(AI(), AsyncIterable)
+ self.assertIsSubclass(AI, AsyncIterable)
# Check some non-iterables
non_samples = [None, object, []]
for x in non_samples:
self.assertNotIsInstance(x, AsyncIterable)
- self.assertFalse(issubclass(type(x), AsyncIterable), repr(type(x)))
+ self.assertNotIsSubclass(type(x), AsyncIterable)
self.validate_abstract_methods(AsyncIterable, '__aiter__')
self.validate_isinstance(AsyncIterable, '__aiter__')
@@ -949,13 +949,13 @@ def __aiter__(self):
return self
async def __anext__(self):
raise StopAsyncIteration
- self.assertTrue(isinstance(AI(), AsyncIterator))
- self.assertTrue(issubclass(AI, AsyncIterator))
+ self.assertIsInstance(AI(), AsyncIterator)
+ self.assertIsSubclass(AI, AsyncIterator)
non_samples = [None, object, []]
# Check some non-iterables
for x in non_samples:
self.assertNotIsInstance(x, AsyncIterator)
- self.assertFalse(issubclass(type(x), AsyncIterator), repr(type(x)))
+ self.assertNotIsSubclass(type(x), AsyncIterator)
# Similarly to regular iterators (see issue 10565)
class AnextOnly:
async def __anext__(self):
@@ -968,7 +968,7 @@ def test_Iterable(self):
non_samples = [None, 42, 3.14, 1j]
for x in non_samples:
self.assertNotIsInstance(x, Iterable)
- self.assertFalse(issubclass(type(x), Iterable), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Iterable)
# Check some iterables
samples = [bytes(), str(),
tuple(), list(), set(), frozenset(), dict(),
@@ -978,13 +978,13 @@ def test_Iterable(self):
]
for x in samples:
self.assertIsInstance(x, Iterable)
- self.assertTrue(issubclass(type(x), Iterable), repr(type(x)))
+ self.assertIsSubclass(type(x), Iterable)
# Check direct subclassing
class I(Iterable):
def __iter__(self):
return super().__iter__()
self.assertEqual(list(I()), [])
- self.assertFalse(issubclass(str, I))
+ self.assertNotIsSubclass(str, I)
self.validate_abstract_methods(Iterable, '__iter__')
self.validate_isinstance(Iterable, '__iter__')
# Check None blocking
@@ -992,22 +992,22 @@ class It:
def __iter__(self): return iter([])
class ItBlocked(It):
__iter__ = None
- self.assertTrue(issubclass(It, Iterable))
- self.assertTrue(isinstance(It(), Iterable))
- self.assertFalse(issubclass(ItBlocked, Iterable))
- self.assertFalse(isinstance(ItBlocked(), Iterable))
+ self.assertIsSubclass(It, Iterable)
+ self.assertIsInstance(It(), Iterable)
+ self.assertNotIsSubclass(ItBlocked, Iterable)
+ self.assertNotIsInstance(ItBlocked(), Iterable)
def test_Reversible(self):
# Check some non-reversibles
non_samples = [None, 42, 3.14, 1j, set(), frozenset()]
for x in non_samples:
self.assertNotIsInstance(x, Reversible)
- self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Reversible)
# Check some non-reversible iterables
non_reversibles = [_test_gen(), (x for x in []), iter([]),
reversed([])]
for x in non_reversibles:
self.assertNotIsInstance(x, Reversible)
- self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Reversible)
# Check some reversible iterables
samples = [bytes(), str(), tuple(), list(), OrderedDict(),
OrderedDict().keys(), OrderedDict().items(),
@@ -1016,11 +1016,11 @@ def test_Reversible(self):
dict().keys(), dict().items(), dict().values()]
for x in samples:
self.assertIsInstance(x, Reversible)
- self.assertTrue(issubclass(type(x), Reversible), repr(type(x)))
+ self.assertIsSubclass(type(x), Reversible)
# Check also Mapping, MutableMapping, and Sequence
- self.assertTrue(issubclass(Sequence, Reversible), repr(Sequence))
- self.assertFalse(issubclass(Mapping, Reversible), repr(Mapping))
- self.assertFalse(issubclass(MutableMapping, Reversible),
repr(MutableMapping))
+ self.assertIsSubclass(Sequence, Reversible)
+ self.assertNotIsSubclass(Mapping, Reversible)
+ self.assertNotIsSubclass(MutableMapping, Reversible)
# Check direct subclassing
class R(Reversible):
def __iter__(self):
@@ -1028,17 +1028,17 @@ def __iter__(self):
def __reversed__(self):
return iter(list())
self.assertEqual(list(reversed(R())), [])
- self.assertFalse(issubclass(float, R))
+ self.assertNotIsSubclass(float, R)
self.validate_abstract_methods(Reversible, '__reversed__', '__iter__')
# Check reversible non-iterable (which is not Reversible)
class RevNoIter:
def __reversed__(self): return reversed([])
class RevPlusIter(RevNoIter):
def __iter__(self): return iter([])
- self.assertFalse(issubclass(RevNoIter, Reversible))
- self.assertFalse(isinstance(RevNoIter(), Reversible))
- self.assertTrue(issubclass(RevPlusIter, Reversible))
- self.assertTrue(isinstance(RevPlusIter(), Reversible))
+ self.assertNotIsSubclass(RevNoIter, Reversible)
+ self.assertNotIsInstance(RevNoIter(), Reversible)
+ self.assertIsSubclass(RevPlusIter, Reversible)
+ self.assertIsInstance(RevPlusIter(), Reversible)
# Check None blocking
class Rev:
def __iter__(self): return iter([])
@@ -1047,39 +1047,38 @@ class RevItBlocked(Rev):
__iter__ = None
class RevRevBlocked(Rev):
__reversed__ = None
- self.assertTrue(issubclass(Rev, Reversible))
- self.assertTrue(isinstance(Rev(), Reversible))
- self.assertFalse(issubclass(RevItBlocked, Reversible))
- self.assertFalse(isinstance(RevItBlocked(), Reversible))
- self.assertFalse(issubclass(RevRevBlocked, Reversible))
- self.assertFalse(isinstance(RevRevBlocked(), Reversible))
+ self.assertIsSubclass(Rev, Reversible)
+ self.assertIsInstance(Rev(), Reversible)
+ self.assertNotIsSubclass(RevItBlocked, Reversible)
+ self.assertNotIsInstance(RevItBlocked(), Reversible)
+ self.assertNotIsSubclass(RevRevBlocked, Reversible)
+ self.assertNotIsInstance(RevRevBlocked(), Reversible)
def test_Collection(self):
# Check some non-collections
non_collections = [None, 42, 3.14, 1j, lambda x: 2*x]
for x in non_collections:
self.assertNotIsInstance(x, Collection)
- self.assertFalse(issubclass(type(x), Collection), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Collection)
# Check some non-collection iterables
non_col_iterables = [_test_gen(), iter(b''), iter(bytearray()),
(x for x in [])]
for x in non_col_iterables:
self.assertNotIsInstance(x, Collection)
- self.assertFalse(issubclass(type(x), Collection), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Collection)
# Check some collections
samples = [set(), frozenset(), dict(), bytes(), str(), tuple(),
list(), dict().keys(), dict().items(), dict().values()]
for x in samples:
self.assertIsInstance(x, Collection)
- self.assertTrue(issubclass(type(x), Collection), repr(type(x)))
+ self.assertIsSubclass(type(x), Collection)
# Check also Mapping, MutableMapping, etc.
- self.assertTrue(issubclass(Sequence, Collection), repr(Sequence))
- self.assertTrue(issubclass(Mapping, Collection), repr(Mapping))
- self.assertTrue(issubclass(MutableMapping, Collection),
- repr(MutableMapping))
- self.assertTrue(issubclass(Set, Collection), repr(Set))
- self.assertTrue(issubclass(MutableSet, Collection), repr(MutableSet))
- self.assertTrue(issubclass(Sequence, Collection), repr(MutableSet))
+ self.assertIsSubclass(Sequence, Collection)
+ self.assertIsSubclass(Mapping, Collection)
+ self.assertIsSubclass(MutableMapping, Collection)
+ self.assertIsSubclass(Set, Collection)
+ self.assertIsSubclass(MutableSet, Collection)
+ self.assertIsSubclass(Sequence, Collection)
# Check direct subclassing
class Col(Collection):
def __iter__(self):
@@ -1090,13 +1089,13 @@ def __contains__(self, item):
return False
class DerCol(Col): pass
self.assertEqual(list(iter(Col())), [])
- self.assertFalse(issubclass(list, Col))
- self.assertFalse(issubclass(set, Col))
- self.assertFalse(issubclass(float, Col))
+ self.assertNotIsSubclass(list, Col)
+ self.assertNotIsSubclass(set, Col)
+ self.assertNotIsSubclass(float, Col)
self.assertEqual(list(iter(DerCol())), [])
- self.assertFalse(issubclass(list, DerCol))
- self.assertFalse(issubclass(set, DerCol))
- self.assertFalse(issubclass(float, DerCol))
+ self.assertNotIsSubclass(list, DerCol)
+ self.assertNotIsSubclass(set, DerCol)
+ self.assertNotIsSubclass(float, DerCol)
self.validate_abstract_methods(Collection, '__len__', '__iter__',
'__contains__')
# Check sized container non-iterable (which is not Collection) etc.
@@ -1109,12 +1108,12 @@ def __contains__(self, item): return False
class ColNoCont:
def __iter__(self): return iter([])
def __len__(self): return 0
- self.assertFalse(issubclass(ColNoIter, Collection))
- self.assertFalse(isinstance(ColNoIter(), Collection))
- self.assertFalse(issubclass(ColNoSize, Collection))
- self.assertFalse(isinstance(ColNoSize(), Collection))
- self.assertFalse(issubclass(ColNoCont, Collection))
- self.assertFalse(isinstance(ColNoCont(), Collection))
+ self.assertNotIsSubclass(ColNoIter, Collection)
+ self.assertNotIsInstance(ColNoIter(), Collection)
+ self.assertNotIsSubclass(ColNoSize, Collection)
+ self.assertNotIsInstance(ColNoSize(), Collection)
+ self.assertNotIsSubclass(ColNoCont, Collection)
+ self.assertNotIsInstance(ColNoCont(), Collection)
# Check None blocking
class SizeBlock:
def __iter__(self): return iter([])
@@ -1124,10 +1123,10 @@ class IterBlock:
def __len__(self): return 0
def __contains__(self): return True
__iter__ = None
- self.assertFalse(issubclass(SizeBlock, Collection))
- self.assertFalse(isinstance(SizeBlock(), Collection))
- self.assertFalse(issubclass(IterBlock, Collection))
- self.assertFalse(isinstance(IterBlock(), Collection))
+ self.assertNotIsSubclass(SizeBlock, Collection)
+ self.assertNotIsInstance(SizeBlock(), Collection)
+ self.assertNotIsSubclass(IterBlock, Collection)
+ self.assertNotIsInstance(IterBlock(), Collection)
# Check None blocking in subclass
class ColImpl:
def __iter__(self):
@@ -1138,15 +1137,15 @@ def __contains__(self, item):
return False
class NonCol(ColImpl):
__contains__ = None
- self.assertFalse(issubclass(NonCol, Collection))
- self.assertFalse(isinstance(NonCol(), Collection))
+ self.assertNotIsSubclass(NonCol, Collection)
+ self.assertNotIsInstance(NonCol(), Collection)
def test_Iterator(self):
non_samples = [None, 42, 3.14, 1j, b"", "", (), [], {}, set()]
for x in non_samples:
self.assertNotIsInstance(x, Iterator)
- self.assertFalse(issubclass(type(x), Iterator), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Iterator)
samples = [iter(bytes()), iter(str()),
iter(tuple()), iter(list()), iter(dict()),
iter(set()), iter(frozenset()),
@@ -1157,7 +1156,7 @@ def test_Iterator(self):
]
for x in samples:
self.assertIsInstance(x, Iterator)
- self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))
+ self.assertIsSubclass(type(x), Iterator)
self.validate_abstract_methods(Iterator, '__next__', '__iter__')
# Issue 10565
@@ -1190,7 +1189,7 @@ def throw(self, typ, val=None, tb=None): pass
iter(()), iter([]), NonGen1(), NonGen2(), NonGen3()]
for x in non_samples:
self.assertNotIsInstance(x, Generator)
- self.assertFalse(issubclass(type(x), Generator), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Generator)
class Gen:
def __iter__(self): return self
@@ -1212,7 +1211,7 @@ def gen():
for x in samples:
self.assertIsInstance(x, Iterator)
self.assertIsInstance(x, Generator)
- self.assertTrue(issubclass(type(x), Generator), repr(type(x)))
+ self.assertIsSubclass(type(x), Generator)
self.validate_abstract_methods(Generator, 'send', 'throw')
# mixin tests
@@ -1261,7 +1260,7 @@ def athrow(self, typ, val=None, tb=None): pass
iter(()), iter([]), NonAGen1(), NonAGen2(), NonAGen3()]
for x in non_samples:
self.assertNotIsInstance(x, AsyncGenerator)
- self.assertFalse(issubclass(type(x), AsyncGenerator),
repr(type(x)))
+ self.assertNotIsSubclass(type(x), AsyncGenerator)
class Gen:
def __aiter__(self): return self
@@ -1283,7 +1282,7 @@ async def gen():
for x in samples:
self.assertIsInstance(x, AsyncIterator)
self.assertIsInstance(x, AsyncGenerator)
- self.assertTrue(issubclass(type(x), AsyncGenerator), repr(type(x)))
+ self.assertIsSubclass(type(x), AsyncGenerator)
self.validate_abstract_methods(AsyncGenerator, 'asend', 'athrow')
def run_async(coro):
@@ -1326,14 +1325,14 @@ def test_Sized(self):
]
for x in non_samples:
self.assertNotIsInstance(x, Sized)
- self.assertFalse(issubclass(type(x), Sized), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Sized)
samples = [bytes(), str(),
tuple(), list(), set(), frozenset(), dict(),
dict().keys(), dict().items(), dict().values(),
]
for x in samples:
self.assertIsInstance(x, Sized)
- self.assertTrue(issubclass(type(x), Sized), repr(type(x)))
+ self.assertIsSubclass(type(x), Sized)
self.validate_abstract_methods(Sized, '__len__')
self.validate_isinstance(Sized, '__len__')
@@ -1344,14 +1343,14 @@ def test_Container(self):
]
for x in non_samples:
self.assertNotIsInstance(x, Container)
- self.assertFalse(issubclass(type(x), Container), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Container)
samples = [bytes(), str(),
tuple(), list(), set(), frozenset(), dict(),
dict().keys(), dict().items(),
]
for x in samples:
self.assertIsInstance(x, Container)
- self.assertTrue(issubclass(type(x), Container), repr(type(x)))
+ self.assertIsSubclass(type(x), Container)
self.validate_abstract_methods(Container, '__contains__')
self.validate_isinstance(Container, '__contains__')
@@ -1363,7 +1362,7 @@ def test_Callable(self):
]
for x in non_samples:
self.assertNotIsInstance(x, Callable)
- self.assertFalse(issubclass(type(x), Callable), repr(type(x)))
+ self.assertNotIsSubclass(type(x), Callable)
samples = [lambda: None,
type, int, object,
len,
@@ -1371,7 +1370,7 @@ def test_Callable(self):
]
for x in samples:
self.assertIsInstance(x, Callable)
- self.assertTrue(issubclass(type(x), Callable), repr(type(x)))
+ self.assertIsSubclass(type(x), Callable)
self.validate_abstract_methods(Callable, '__call__')
self.validate_isinstance(Callable, '__call__')
@@ -1379,16 +1378,16 @@ def test_direct_subclassing(self):
for B in Hashable, Iterable, Iterator, Reversible, Sized, Container,
Callable:
class C(B):
pass
- self.assertTrue(issubclass(C, B))
- self.assertFalse(issubclass(int, C))
+ self.assertIsSubclass(C, B)
+ self.assertNotIsSubclass(int, C)
def test_registration(self):
for B in Hashable, Iterable, Iterator, Reversible, Sized, Container,
Callable:
class C:
__hash__ = None # Make sure it isn't hashable by default
- self.assertFalse(issubclass(C, B), B.__name__)
+ self.assertNotIsSubclass(C, B)
B.register(C)
- self.assertTrue(issubclass(C, B))
+ self.assertIsSubclass(C, B)
class WithSet(MutableSet):
@@ -1419,7 +1418,7 @@ class TestCollectionABCs(ABCTestCase):
def test_Set(self):
for sample in [set, frozenset]:
self.assertIsInstance(sample(), Set)
- self.assertTrue(issubclass(sample, Set))
+ self.assertIsSubclass(sample, Set)
self.validate_abstract_methods(Set, '__contains__', '__iter__',
'__len__')
class MySet(Set):
def __contains__(self, x):
@@ -1500,9 +1499,9 @@ def __len__(self):
def test_MutableSet(self):
self.assertIsInstance(set(), MutableSet)
- self.assertTrue(issubclass(set, MutableSet))
+ self.assertIsSubclass(set, MutableSet)
self.assertNotIsInstance(frozenset(), MutableSet)
- self.assertFalse(issubclass(frozenset, MutableSet))
+ self.assertNotIsSubclass(frozenset, MutableSet)
self.validate_abstract_methods(MutableSet, '__contains__', '__iter__',
'__len__',
'add', 'discard')
@@ -1841,7 +1840,7 @@ def test_Set_hash_matches_frozenset(self):
def test_Mapping(self):
for sample in [dict]:
self.assertIsInstance(sample(), Mapping)
- self.assertTrue(issubclass(sample, Mapping))
+ self.assertIsSubclass(sample, Mapping)
self.validate_abstract_methods(Mapping, '__contains__', '__iter__',
'__len__',
'__getitem__')
class MyMapping(Mapping):
@@ -1857,7 +1856,7 @@ def __iter__(self):
def test_MutableMapping(self):
for sample in [dict]:
self.assertIsInstance(sample(), MutableMapping)
- self.assertTrue(issubclass(sample, MutableMapping))
+ self.assertIsSubclass(sample, MutableMapping)
self.validate_abstract_methods(MutableMapping, '__contains__',
'__iter__', '__len__',
'__getitem__', '__setitem__', '__delitem__')
@@ -1891,12 +1890,12 @@ def test_MutableMapping_subclass(self):
def test_Sequence(self):
for sample in [tuple, list, bytes, str]:
self.assertIsInstance(sample(), Sequence)
- self.assertTrue(issubclass(sample, Sequence))
+ self.assertIsSubclass(sample, Sequence)
self.assertIsInstance(range(10), Sequence)
- self.assertTrue(issubclass(range, Sequence))
+ self.assertIsSubclass(range, Sequence)
self.assertIsInstance(memoryview(b""), Sequence)
- self.assertTrue(issubclass(memoryview, Sequence))
- self.assertTrue(issubclass(str, Sequence))
+ self.assertIsSubclass(memoryview, Sequence)
+ self.assertIsSubclass(str, Sequence)
self.validate_abstract_methods(Sequence, '__contains__', '__iter__',
'__len__',
'__getitem__')
@@ -1938,21 +1937,21 @@ def assert_index_same(seq1, seq2, index_args):
def test_Buffer(self):
for sample in [bytes, bytearray, memoryview]:
self.assertIsInstance(sample(b"x"), Buffer)
- self.assertTrue(issubclass(sample, Buffer))
+ self.assertIsSubclass(sample, Buffer)
for sample in [str, list, tuple]:
self.assertNotIsInstance(sample(), Buffer)
- self.assertFalse(issubclass(sample, Buffer))
+ self.assertNotIsSubclass(sample, Buffer)
self.validate_abstract_methods(Buffer, '__buffer__')
def test_MutableSequence(self):
for sample in [tuple, str, bytes]:
self.assertNotIsInstance(sample(), MutableSequence)
- self.assertFalse(issubclass(sample, MutableSequence))
+ self.assertNotIsSubclass(sample, MutableSequence)
for sample in [list, bytearray, deque]:
self.assertIsInstance(sample(), MutableSequence)
- self.assertTrue(issubclass(sample, MutableSequence))
- self.assertTrue(issubclass(array.array, MutableSequence))
- self.assertFalse(issubclass(str, MutableSequence))
+ self.assertIsSubclass(sample, MutableSequence)
+ self.assertIsSubclass(array.array, MutableSequence)
+ self.assertNotIsSubclass(str, MutableSequence)
self.validate_abstract_methods(MutableSequence, '__contains__',
'__iter__',
'__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')
@@ -2043,8 +2042,8 @@ def test_basics(self):
self.assertEqual(c, Counter(a=3, b=2, c=1))
self.assertIsInstance(c, dict)
self.assertIsInstance(c, Mapping)
- self.assertTrue(issubclass(Counter, dict))
- self.assertTrue(issubclass(Counter, Mapping))
+ self.assertIsSubclass(Counter, dict)
+ self.assertIsSubclass(Counter, Mapping)
self.assertEqual(len(c), 3)
self.assertEqual(sum(c.values()), 6)
self.assertEqual(list(c.values()), [3, 2, 1])
_______________________________________________
Python-checkins mailing list -- [email protected]
To unsubscribe send an email to [email protected]
https://mail.python.org/mailman3/lists/python-checkins.python.org/
Member address: [email protected]
