Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-11-04 07:31:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

use assert[Not]IsInstance where appropriate

Browse source
This commit is contained in:
Ezio Melotti 2010-01-24 16:58:36 +00:00
parent f14c7fc33d
commit b0f5adc3f4
57 changed files with 269 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Lib/test/mapping_tests.py
View file

@ -451,7 +451,7 @@ def __new__(cls):
ud = mydict.fromkeys('ab') ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None}) self.assertEqual(ud, {'a':None, 'b':None})
# FIXME: the following won't work with UserDict, because it's an old style class # FIXME: the following won't work with UserDict, because it's an old style class
# self.assertTrue(isinstance(ud, UserDict.UserDict)) # self.assertIsInstance(ud, UserDict.UserDict)
self.assertRaises(TypeError, dict.fromkeys) self.assertRaises(TypeError, dict.fromkeys)
class Exc(Exception): pass class Exc(Exception): pass
@ -481,7 +481,7 @@ def test_copy(self):
self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
d = self._empty_mapping() d = self._empty_mapping()
self.assertEqual(d.copy(), d) self.assertEqual(d.copy(), d)
self.assertTrue(isinstance(d.copy(), d.__class__)) self.assertIsInstance(d.copy(), d.__class__)
self.assertRaises(TypeError, d.copy, None) self.assertRaises(TypeError, d.copy, None)
def test_get(self): def test_get(self):
@ -586,7 +586,7 @@ def __new__(cls):
return UserDict.UserDict() return UserDict.UserDict()
ud = mydict.fromkeys('ab') ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None}) self.assertEqual(ud, {'a':None, 'b':None})
self.assertTrue(isinstance(ud, UserDict.UserDict)) self.assertIsInstance(ud, UserDict.UserDict)
def test_pop(self): def test_pop(self):
TestMappingProtocol.test_pop(self) TestMappingProtocol.test_pop(self)

24
Lib/test/test_abc.py
View file

@ -89,20 +89,20 @@ class B(object):
b = B() b = B()
self.assertEqual(issubclass(B, A), False) self.assertEqual(issubclass(B, A), False)
self.assertEqual(issubclass(B, (A,)), False) self.assertEqual(issubclass(B, (A,)), False)
self.assertEqual(isinstance(b, A), False) self.assertNotIsInstance(b, A)
self.assertEqual(isinstance(b, (A,)), False) self.assertNotIsInstance(b, (A,))
A.register(B) A.register(B)
self.assertEqual(issubclass(B, A), True) self.assertEqual(issubclass(B, A), True)
self.assertEqual(issubclass(B, (A,)), True) self.assertEqual(issubclass(B, (A,)), True)
self.assertEqual(isinstance(b, A), True) self.assertIsInstance(b, A)
self.assertEqual(isinstance(b, (A,)), True) self.assertIsInstance(b, (A,))
class C(B): class C(B):
pass pass
c = C() c = C()
self.assertEqual(issubclass(C, A), True) self.assertEqual(issubclass(C, A), True)
self.assertEqual(issubclass(C, (A,)), True) self.assertEqual(issubclass(C, (A,)), True)
self.assertEqual(isinstance(c, A), True) self.assertIsInstance(c, A)
self.assertEqual(isinstance(c, (A,)), True) self.assertIsInstance(c, (A,))
def test_isinstance_invalidation(self): def test_isinstance_invalidation(self):
class A: class A:
@ -120,15 +120,15 @@ def test_registration_builtins(self):
class A: class A:
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
A.register(int) A.register(int)
self.assertEqual(isinstance(42, A), True) self.assertIsInstance(42, A)
self.assertEqual(isinstance(42, (A,)), True) self.assertIsInstance(42, (A,))
self.assertEqual(issubclass(int, A), True) self.assertEqual(issubclass(int, A), True)
self.assertEqual(issubclass(int, (A,)), True) self.assertEqual(issubclass(int, (A,)), True)
class B(A): class B(A):
pass pass
B.register(basestring) B.register(basestring)
self.assertEqual(isinstance("", A), True) self.assertIsInstance("", A)
self.assertEqual(isinstance("", (A,)), True) self.assertIsInstance("", (A,))
self.assertEqual(issubclass(str, A), True) self.assertEqual(issubclass(str, A), True)
self.assertEqual(issubclass(str, (A,)), True) self.assertEqual(issubclass(str, (A,)), True)
@ -185,8 +185,8 @@ class MyInt(int):
pass pass
self.assertTrue(issubclass(MyInt, A)) self.assertTrue(issubclass(MyInt, A))
self.assertTrue(issubclass(MyInt, (A,))) self.assertTrue(issubclass(MyInt, (A,)))
self.assertTrue(isinstance(42, A)) self.assertIsInstance(42, A)
self.assertTrue(isinstance(42, (A,))) self.assertIsInstance(42, (A,))
def test_all_new_methods_are_called(self): def test_all_new_methods_are_called(self):
class A: class A:

6
Lib/test/test_array.py
View file

@ -63,10 +63,10 @@ def test_buffer_info(self):
a = array.array(self.typecode, self.example) a = array.array(self.typecode, self.example)
self.assertRaises(TypeError, a.buffer_info, 42) self.assertRaises(TypeError, a.buffer_info, 42)
bi = a.buffer_info() bi = a.buffer_info()
self.assertTrue(isinstance(bi, tuple)) self.assertIsInstance(bi, tuple)
self.assertEqual(len(bi), 2) self.assertEqual(len(bi), 2)
self.assertTrue(isinstance(bi[0], (int, long))) self.assertIsInstance(bi[0], (int, long))
self.assertTrue(isinstance(bi[1], int)) self.assertIsInstance(bi[1], int)
self.assertEqual(bi[1], len(a)) self.assertEqual(bi[1], len(a))
def test_byteswap(self): def test_byteswap(self):

2
Lib/test/test_ast.py
View file

@ -154,7 +154,7 @@ def test_slice(self):
slc = ast.parse("x[::]").body[0].value.slice slc = ast.parse("x[::]").body[0].value.slice
self.assertIsNone(slc.upper) self.assertIsNone(slc.upper)
self.assertIsNone(slc.lower) self.assertIsNone(slc.lower)
self.assertTrue(isinstance(slc.step, ast.Name)) self.assertIsInstance(slc.step, ast.Name)
self.assertEqual(slc.step.id, "None") self.assertEqual(slc.step.id, "None")
def test_from_import(self): def test_from_import(self):

4
Lib/test/test_augassign.py
View file

@ -99,7 +99,7 @@ def __iadd__(self, val):
y = x y = x
x += 10 x += 10
self.assertTrue(isinstance(x, aug_test)) self.assertIsInstance(x, aug_test)
self.assertTrue(y is not x) self.assertTrue(y is not x)
self.assertEquals(x.val, 11) self.assertEquals(x.val, 11)
@ -114,7 +114,7 @@ def __iadd__(self, val):
y = x y = x
x += 10 x += 10
self.assertTrue(isinstance(x, aug_test3)) self.assertIsInstance(x, aug_test3)
self.assertTrue(y is not x) self.assertTrue(y is not x)
self.assertEquals(x.val, 13) self.assertEquals(x.val, 13)

6
Lib/test/test_bool.py
View file

@ -233,15 +233,15 @@ def test_string(self):
def test_boolean(self): def test_boolean(self):
self.assertEqual(True & 1, 1) self.assertEqual(True & 1, 1)
self.assertTrue(not isinstance(True & 1, bool)) self.assertNotIsInstance(True & 1, bool)
self.assertIs(True & True, True) self.assertIs(True & True, True)
self.assertEqual(True | 1, 1) self.assertEqual(True | 1, 1)
self.assertTrue(not isinstance(True | 1, bool)) self.assertNotIsInstance(True | 1, bool)
self.assertIs(True | True, True) self.assertIs(True | True, True)
self.assertEqual(True ^ 1, 0) self.assertEqual(True ^ 1, 0)
self.assertTrue(not isinstance(True ^ 1, bool)) self.assertNotIsInstance(True ^ 1, bool)
self.assertIs(True ^ True, False) self.assertIs(True ^ True, False)
def test_fileclosed(self): def test_fileclosed(self):

2
Lib/test/test_bytes.py
View file

@ -970,7 +970,7 @@ class ByteArraySubclassTest(unittest.TestCase):
def test_basic(self): def test_basic(self):
self.assertTrue(issubclass(ByteArraySubclass, bytearray)) self.assertTrue(issubclass(ByteArraySubclass, bytearray))
self.assertTrue(isinstance(ByteArraySubclass(), bytearray)) self.assertIsInstance(ByteArraySubclass(), bytearray)
a, b = b"abcd", b"efgh" a, b = b"abcd", b"efgh"
_a, _b = ByteArraySubclass(a), ByteArraySubclass(b) _a, _b = ByteArraySubclass(a), ByteArraySubclass(b)

4
Lib/test/test_codecs.py
View file

@ -1141,14 +1141,14 @@ def test_read(self):
reader = codecs.getreader("base64_codec")(StringIO.StringIO(sin)) reader = codecs.getreader("base64_codec")(StringIO.StringIO(sin))
sout = reader.read() sout = reader.read()
self.assertEqual(sout, "\x80") self.assertEqual(sout, "\x80")
self.assertTrue(isinstance(sout, str)) self.assertIsInstance(sout, str)
def test_readline(self): def test_readline(self):
sin = "\x80".encode("base64_codec") sin = "\x80".encode("base64_codec")
reader = codecs.getreader("base64_codec")(StringIO.StringIO(sin)) reader = codecs.getreader("base64_codec")(StringIO.StringIO(sin))
sout = reader.readline() sout = reader.readline()
self.assertEqual(sout, "\x80") self.assertEqual(sout, "\x80")
self.assertTrue(isinstance(sout, str)) self.assertIsInstance(sout, str)
all_unicode_encodings = [ all_unicode_encodings = [
"ascii", "ascii",

48
Lib/test/test_collections.py
View file

@ -101,7 +101,7 @@ def test_tupleness(self):
Point = namedtuple('Point', 'x y') Point = namedtuple('Point', 'x y')
p = Point(11, 22) p = Point(11, 22)
self.assertTrue(isinstance(p, tuple)) self.assertIsInstance(p, tuple)
self.assertEqual(p, (11, 22)) # matches a real tuple self.assertEqual(p, (11, 22)) # matches a real tuple
self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple
self.assertEqual(list(p), [11, 22]) # coercable to a list self.assertEqual(list(p), [11, 22]) # coercable to a list
@ -233,7 +233,7 @@ def test_Hashable(self):
# Check some non-hashables # Check some non-hashables
non_samples = [list(), set(), dict()] non_samples = [list(), set(), dict()]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Hashable), repr(x)) self.assertNotIsInstance(x, Hashable)
self.assertFalse(issubclass(type(x), Hashable), repr(type(x))) self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
# Check some hashables # Check some hashables
samples = [None, samples = [None,
@ -243,7 +243,7 @@ def test_Hashable(self):
int, list, object, type, int, list, object, type,
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Hashable), repr(x)) self.assertIsInstance(x, Hashable)
self.assertTrue(issubclass(type(x), Hashable), repr(type(x))) self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
self.assertRaises(TypeError, Hashable) self.assertRaises(TypeError, Hashable)
# Check direct subclassing # Check direct subclassing
@ -259,7 +259,7 @@ def test_Iterable(self):
# Check some non-iterables # Check some non-iterables
non_samples = [None, 42, 3.14, 1j] non_samples = [None, 42, 3.14, 1j]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Iterable), repr(x)) self.assertNotIsInstance(x, Iterable)
self.assertFalse(issubclass(type(x), Iterable), repr(type(x))) self.assertFalse(issubclass(type(x), Iterable), repr(type(x)))
# Check some iterables # Check some iterables
samples = [str(), samples = [str(),
@ -269,7 +269,7 @@ def test_Iterable(self):
(x for x in []), (x for x in []),
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Iterable), repr(x)) self.assertIsInstance(x, Iterable)
self.assertTrue(issubclass(type(x), Iterable), repr(type(x))) self.assertTrue(issubclass(type(x), Iterable), repr(type(x)))
# Check direct subclassing # Check direct subclassing
class I(Iterable): class I(Iterable):
@ -283,7 +283,7 @@ def test_Iterator(self):
non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [], non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [],
{}, set()] {}, set()]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Iterator), repr(x)) self.assertNotIsInstance(x, Iterator)
self.assertFalse(issubclass(type(x), Iterator), repr(type(x))) self.assertFalse(issubclass(type(x), Iterator), repr(type(x)))
samples = [iter(str()), samples = [iter(str()),
iter(tuple()), iter(list()), iter(dict()), iter(tuple()), iter(list()), iter(dict()),
@ -294,7 +294,7 @@ def test_Iterator(self):
(x for x in []), (x for x in []),
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Iterator), repr(x)) self.assertIsInstance(x, Iterator)
self.assertTrue(issubclass(type(x), Iterator), repr(type(x))) self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))
self.validate_abstract_methods(Iterator, 'next') self.validate_abstract_methods(Iterator, 'next')
@ -304,14 +304,14 @@ def test_Sized(self):
(x for x in []), (x for x in []),
] ]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Sized), repr(x)) self.assertNotIsInstance(x, Sized)
self.assertFalse(issubclass(type(x), Sized), repr(type(x))) self.assertFalse(issubclass(type(x), Sized), repr(type(x)))
samples = [str(), samples = [str(),
tuple(), list(), set(), frozenset(), dict(), tuple(), list(), set(), frozenset(), dict(),
dict().keys(), dict().items(), dict().values(), dict().keys(), dict().items(), dict().values(),
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Sized), repr(x)) self.assertIsInstance(x, Sized)
self.assertTrue(issubclass(type(x), Sized), repr(type(x))) self.assertTrue(issubclass(type(x), Sized), repr(type(x)))
self.validate_abstract_methods(Sized, '__len__') self.validate_abstract_methods(Sized, '__len__')
@ -321,14 +321,14 @@ def test_Container(self):
(x for x in []), (x for x in []),
] ]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Container), repr(x)) self.assertNotIsInstance(x, Container)
self.assertFalse(issubclass(type(x), Container), repr(type(x))) self.assertFalse(issubclass(type(x), Container), repr(type(x)))
samples = [str(), samples = [str(),
tuple(), list(), set(), frozenset(), dict(), tuple(), list(), set(), frozenset(), dict(),
dict().keys(), dict().items(), dict().keys(), dict().items(),
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Container), repr(x)) self.assertIsInstance(x, Container)
self.assertTrue(issubclass(type(x), Container), repr(type(x))) self.assertTrue(issubclass(type(x), Container), repr(type(x)))
self.validate_abstract_methods(Container, '__contains__') self.validate_abstract_methods(Container, '__contains__')
@ -339,7 +339,7 @@ def test_Callable(self):
(x for x in []), (x for x in []),
] ]
for x in non_samples: for x in non_samples:
self.assertFalse(isinstance(x, Callable), repr(x)) self.assertNotIsInstance(x, Callable)
self.assertFalse(issubclass(type(x), Callable), repr(type(x))) self.assertFalse(issubclass(type(x), Callable), repr(type(x)))
samples = [lambda: None, samples = [lambda: None,
type, int, object, type, int, object,
@ -347,7 +347,7 @@ def test_Callable(self):
list.append, [].append, list.append, [].append,
] ]
for x in samples: for x in samples:
self.assertTrue(isinstance(x, Callable), repr(x)) self.assertIsInstance(x, Callable)
self.assertTrue(issubclass(type(x), Callable), repr(type(x))) self.assertTrue(issubclass(type(x), Callable), repr(type(x)))
self.validate_abstract_methods(Callable, '__call__') self.validate_abstract_methods(Callable, '__call__')
@ -395,7 +395,7 @@ class TestCollectionABCs(ABCTestCase):
def test_Set(self): def test_Set(self):
for sample in [set, frozenset]: for sample in [set, frozenset]:
self.assertTrue(isinstance(sample(), Set)) self.assertIsInstance(sample(), Set)
self.assertTrue(issubclass(sample, Set)) self.assertTrue(issubclass(sample, Set))
self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__') self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')
@ -415,9 +415,9 @@ def __hash__(self):
self.assertTrue(hash(a) == hash(b)) self.assertTrue(hash(a) == hash(b))
def test_MutableSet(self): def test_MutableSet(self):
self.assertTrue(isinstance(set(), MutableSet)) self.assertIsInstance(set(), MutableSet)
self.assertTrue(issubclass(set, MutableSet)) self.assertTrue(issubclass(set, MutableSet))
self.assertFalse(isinstance(frozenset(), MutableSet)) self.assertNotIsInstance(frozenset(), MutableSet)
self.assertFalse(issubclass(frozenset, MutableSet)) self.assertFalse(issubclass(frozenset, MutableSet))
self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__', self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',
'add', 'discard') 'add', 'discard')
@ -457,24 +457,24 @@ def __repr__(self):
def test_Mapping(self): def test_Mapping(self):
for sample in [dict]: for sample in [dict]:
self.assertTrue(isinstance(sample(), Mapping)) self.assertIsInstance(sample(), Mapping)
self.assertTrue(issubclass(sample, Mapping)) self.assertTrue(issubclass(sample, Mapping))
self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__', self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',
'__getitem__') '__getitem__')
def test_MutableMapping(self): def test_MutableMapping(self):
for sample in [dict]: for sample in [dict]:
self.assertTrue(isinstance(sample(), MutableMapping)) self.assertIsInstance(sample(), MutableMapping)
self.assertTrue(issubclass(sample, MutableMapping)) self.assertTrue(issubclass(sample, MutableMapping))
self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__', self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',
'__getitem__', '__setitem__', '__delitem__') '__getitem__', '__setitem__', '__delitem__')
def test_Sequence(self): def test_Sequence(self):
for sample in [tuple, list, str]: for sample in [tuple, list, str]:
self.assertTrue(isinstance(sample(), Sequence)) self.assertIsInstance(sample(), Sequence)
self.assertTrue(issubclass(sample, Sequence)) self.assertTrue(issubclass(sample, Sequence))
self.assertTrue(issubclass(basestring, Sequence)) self.assertTrue(issubclass(basestring, Sequence))
self.assertTrue(isinstance(range(10), Sequence)) self.assertIsInstance(range(10), Sequence)
self.assertTrue(issubclass(xrange, Sequence)) self.assertTrue(issubclass(xrange, Sequence))
self.assertTrue(issubclass(str, Sequence)) self.assertTrue(issubclass(str, Sequence))
self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__', self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',
@ -482,10 +482,10 @@ def test_Sequence(self):
def test_MutableSequence(self): def test_MutableSequence(self):
for sample in [tuple, str]: for sample in [tuple, str]:
self.assertFalse(isinstance(sample(), MutableSequence)) self.assertNotIsInstance(sample(), MutableSequence)
self.assertFalse(issubclass(sample, MutableSequence)) self.assertFalse(issubclass(sample, MutableSequence))
for sample in [list]: for sample in [list]:
self.assertTrue(isinstance(sample(), MutableSequence)) self.assertIsInstance(sample(), MutableSequence)
self.assertTrue(issubclass(sample, MutableSequence)) self.assertTrue(issubclass(sample, MutableSequence))
self.assertFalse(issubclass(basestring, MutableSequence)) self.assertFalse(issubclass(basestring, MutableSequence))
self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__', self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',
@ -497,8 +497,8 @@ def test_basics(self):
c = Counter('abcaba') c = Counter('abcaba')
self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1})) self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
self.assertEqual(c, Counter(a=3, b=2, c=1)) self.assertEqual(c, Counter(a=3, b=2, c=1))
self.assertTrue(isinstance(c, dict)) self.assertIsInstance(c, dict)
self.assertTrue(isinstance(c, Mapping)) self.assertIsInstance(c, Mapping)
self.assertTrue(issubclass(Counter, dict)) self.assertTrue(issubclass(Counter, dict))
self.assertTrue(issubclass(Counter, Mapping)) self.assertTrue(issubclass(Counter, Mapping))
self.assertEqual(len(c), 3) self.assertEqual(len(c), 3)

6
Lib/test/test_compile.py
View file

@ -249,8 +249,8 @@ def test_unary_minus(self):
self.fail("How many bits *does* this machine have???") self.fail("How many bits *does* this machine have???")
# Verify treatment of contant folding on -(sys.maxint+1) # Verify treatment of contant folding on -(sys.maxint+1)
# i.e. -2147483648 on 32 bit platforms. Should return int, not long. # i.e. -2147483648 on 32 bit platforms. Should return int, not long.
self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int)) self.assertIsInstance(eval("%s" % (-sys.maxint - 1)), int)
self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), long)) self.assertIsInstance(eval("%s" % (-sys.maxint - 2)), long)
if sys.maxint == 9223372036854775807: if sys.maxint == 9223372036854775807:
def test_32_63_bit_values(self): def test_32_63_bit_values(self):
@ -265,7 +265,7 @@ def test_32_63_bit_values(self):
for variable in self.test_32_63_bit_values.func_code.co_consts: for variable in self.test_32_63_bit_values.func_code.co_consts:
if variable is not None: if variable is not None:
self.assertTrue(isinstance(variable, int)) self.assertIsInstance(variable, int)
def test_sequence_unpacking_error(self): def test_sequence_unpacking_error(self):
# Verify sequence packing/unpacking with "or". SF bug #757818 # Verify sequence packing/unpacking with "or". SF bug #757818

2
Lib/test/test_compiler.py
View file

@ -110,7 +110,7 @@ def check_lineno(self, node):
def _check_lineno(self, node): def _check_lineno(self, node):
if not node.__class__ in NOLINENO: if not node.__class__ in NOLINENO:
self.assertTrue(isinstance(node.lineno, int), self.assertIsInstance(node.lineno, int,
"lineno=%s on %s" % (node.lineno, node.__class__)) "lineno=%s on %s" % (node.lineno, node.__class__))
self.assertTrue(node.lineno > 0, self.assertTrue(node.lineno > 0,
"lineno=%s on %s" % (node.lineno, node.__class__)) "lineno=%s on %s" % (node.lineno, node.__class__))

2
Lib/test/test_cookielib.py
View file

@ -1043,7 +1043,7 @@ def test_Cookie_iterator(self):
for i in range(4): for i in range(4):
i = 0 i = 0
for c in cs: for c in cs:
self.assertTrue(isinstance(c, Cookie)) self.assertIsInstance(c, Cookie)
self.assertEquals(c.version, versions[i]) self.assertEquals(c.version, versions[i])
self.assertEquals(c.name, names[i]) self.assertEquals(c.name, names[i])
self.assertEquals(c.domain, domains[i]) self.assertEquals(c.domain, domains[i])

31
Lib/test/test_datetime.py
View file

@ -81,7 +81,7 @@ def __init__(self, offset, name):
self.__name = name self.__name = name
self.assertTrue(issubclass(NotEnough, tzinfo)) self.assertTrue(issubclass(NotEnough, tzinfo))
ne = NotEnough(3, "NotByALongShot") ne = NotEnough(3, "NotByALongShot")
self.assertTrue(isinstance(ne, tzinfo)) self.assertIsInstance(ne, tzinfo)
dt = datetime.now() dt = datetime.now()
self.assertRaises(NotImplementedError, ne.tzname, dt) self.assertRaises(NotImplementedError, ne.tzname, dt)
@ -90,7 +90,7 @@ def __init__(self, offset, name):
def test_normal(self): def test_normal(self):
fo = FixedOffset(3, "Three") fo = FixedOffset(3, "Three")
self.assertTrue(isinstance(fo, tzinfo)) self.assertIsInstance(fo, tzinfo)
for dt in datetime.now(), None: for dt in datetime.now(), None:
self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3)) self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))
self.assertEqual(fo.tzname(dt), "Three") self.assertEqual(fo.tzname(dt), "Three")
@ -111,14 +111,14 @@ def test_pickling_subclass(self):
# Make sure we can pickle/unpickle an instance of a subclass. # Make sure we can pickle/unpickle an instance of a subclass.
offset = timedelta(minutes=-300) offset = timedelta(minutes=-300)
orig = PicklableFixedOffset(offset, 'cookie') orig = PicklableFixedOffset(offset, 'cookie')
self.assertTrue(isinstance(orig, tzinfo)) self.assertIsInstance(orig, tzinfo)
self.assertTrue(type(orig) is PicklableFixedOffset) self.assertTrue(type(orig) is PicklableFixedOffset)
self.assertEqual(orig.utcoffset(None), offset) self.assertEqual(orig.utcoffset(None), offset)
self.assertEqual(orig.tzname(None), 'cookie') self.assertEqual(orig.tzname(None), 'cookie')
for pickler, unpickler, proto in pickle_choices: for pickler, unpickler, proto in pickle_choices:
green = pickler.dumps(orig, proto) green = pickler.dumps(orig, proto)
derived = unpickler.loads(green) derived = unpickler.loads(green)
self.assertTrue(isinstance(derived, tzinfo)) self.assertIsInstance(derived, tzinfo)
self.assertTrue(type(derived) is PicklableFixedOffset) self.assertTrue(type(derived) is PicklableFixedOffset)
self.assertEqual(derived.utcoffset(None), offset) self.assertEqual(derived.utcoffset(None), offset)
self.assertEqual(derived.tzname(None), 'cookie') self.assertEqual(derived.tzname(None), 'cookie')
@ -391,9 +391,9 @@ def test_roundtrip(self):
self.assertEqual(td, td2) self.assertEqual(td, td2)
def test_resolution_info(self): def test_resolution_info(self):
self.assertTrue(isinstance(timedelta.min, timedelta)) self.assertIsInstance(timedelta.min, timedelta)
self.assertTrue(isinstance(timedelta.max, timedelta)) self.assertIsInstance(timedelta.max, timedelta)
self.assertTrue(isinstance(timedelta.resolution, timedelta)) self.assertIsInstance(timedelta.resolution, timedelta)
self.assertTrue(timedelta.max > timedelta.min) self.assertTrue(timedelta.max > timedelta.min)
self.assertEqual(timedelta.min, timedelta(-999999999)) self.assertEqual(timedelta.min, timedelta(-999999999))
self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1)) self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))
@ -905,9 +905,9 @@ def strftime(self, format_spec):
self.assertEqual(b.__format__(fmt), 'B') self.assertEqual(b.__format__(fmt), 'B')
def test_resolution_info(self): def test_resolution_info(self):
self.assertTrue(isinstance(self.theclass.min, self.theclass)) self.assertIsInstance(self.theclass.min, self.theclass)
self.assertTrue(isinstance(self.theclass.max, self.theclass)) self.assertIsInstance(self.theclass.max, self.theclass)
self.assertTrue(isinstance(self.theclass.resolution, timedelta)) self.assertIsInstance(self.theclass.resolution, timedelta)
self.assertTrue(self.theclass.max > self.theclass.min) self.assertTrue(self.theclass.max > self.theclass.min)
def test_extreme_timedelta(self): def test_extreme_timedelta(self):
@ -1891,9 +1891,9 @@ def test_repr(self):
"%s(23, 15)" % name) "%s(23, 15)" % name)
def test_resolution_info(self): def test_resolution_info(self):
self.assertTrue(isinstance(self.theclass.min, self.theclass)) self.assertIsInstance(self.theclass.min, self.theclass)
self.assertTrue(isinstance(self.theclass.max, self.theclass)) self.assertIsInstance(self.theclass.max, self.theclass)
self.assertTrue(isinstance(self.theclass.resolution, timedelta)) self.assertIsInstance(self.theclass.resolution, timedelta)
self.assertTrue(self.theclass.max > self.theclass.min) self.assertTrue(self.theclass.max > self.theclass.min)
def test_pickling(self): def test_pickling(self):
@ -2260,7 +2260,7 @@ def test_pickling(self):
green = pickler.dumps(orig, proto) green = pickler.dumps(orig, proto)
derived = unpickler.loads(green) derived = unpickler.loads(green)
self.assertEqual(orig, derived) self.assertEqual(orig, derived)
self.assertTrue(isinstance(derived.tzinfo, PicklableFixedOffset)) self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
self.assertEqual(derived.utcoffset(), timedelta(minutes=-300)) self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
self.assertEqual(derived.tzname(), 'cookie') self.assertEqual(derived.tzname(), 'cookie')
@ -2487,8 +2487,7 @@ def test_pickling(self):
green = pickler.dumps(orig, proto) green = pickler.dumps(orig, proto)
derived = unpickler.loads(green) derived = unpickler.loads(green)
self.assertEqual(orig, derived) self.assertEqual(orig, derived)
self.assertTrue(isinstance(derived.tzinfo, self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
PicklableFixedOffset))
self.assertEqual(derived.utcoffset(), timedelta(minutes=-300)) self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
self.assertEqual(derived.tzname(), 'cookie') self.assertEqual(derived.tzname(), 'cookie')

4
Lib/test/test_decimal.py
View file

@ -521,7 +521,7 @@ def test_explicit_context_create_decimal(self):
# from int # from int
d = nc.create_decimal(456) d = nc.create_decimal(456)
self.assertTrue(isinstance(d, Decimal)) self.assertIsInstance(d, Decimal)
self.assertEqual(nc.create_decimal(45678), self.assertEqual(nc.create_decimal(45678),
nc.create_decimal('457E+2')) nc.create_decimal('457E+2'))
@ -1529,7 +1529,7 @@ class DecimalPythonAPItests(unittest.TestCase):
def test_abc(self): def test_abc(self):
self.assertTrue(issubclass(Decimal, numbers.Number)) self.assertTrue(issubclass(Decimal, numbers.Number))
self.assertTrue(not issubclass(Decimal, numbers.Real)) self.assertTrue(not issubclass(Decimal, numbers.Real))
self.assertTrue(isinstance(Decimal(0), numbers.Number)) self.assertIsInstance(Decimal(0), numbers.Number)
self.assertTrue(not isinstance(Decimal(0), numbers.Real)) self.assertTrue(not isinstance(Decimal(0), numbers.Real))
def test_pickle(self): def test_pickle(self):

26
Lib/test/test_descr.py
View file

@ -410,11 +410,11 @@ class ClassPropertiesAndMethods(unittest.TestCase):
def test_python_dicts(self): def test_python_dicts(self):
# Testing Python subclass of dict... # Testing Python subclass of dict...
self.assertTrue(issubclass(dict, dict)) self.assertTrue(issubclass(dict, dict))
self.assertTrue(isinstance({}, dict)) self.assertIsInstance({}, dict)
d = dict() d = dict()
self.assertEqual(d, {}) self.assertEqual(d, {})
self.assertTrue(d.__class__ is dict) self.assertTrue(d.__class__ is dict)
self.assertTrue(isinstance(d, dict)) self.assertIsInstance(d, dict)
class C(dict): class C(dict):
state = -1 state = -1
def __init__(self_local, *a, **kw): def __init__(self_local, *a, **kw):
@ -427,7 +427,7 @@ def __init__(self_local, *a, **kw):
def __getitem__(self, key): def __getitem__(self, key):
return self.get(key, 0) return self.get(key, 0)
def __setitem__(self_local, key, value): def __setitem__(self_local, key, value):
self.assertTrue(isinstance(key, type(0))) self.assertIsInstance(key, type(0))
dict.__setitem__(self_local, key, value) dict.__setitem__(self_local, key, value)
def setstate(self, state): def setstate(self, state):
self.state = state self.state = state
@ -1222,7 +1222,7 @@ class Unrelated(object):
MyABC.register(Unrelated) MyABC.register(Unrelated)
u = Unrelated() u = Unrelated()
self.assertTrue(isinstance(u, MyABC)) self.assertIsInstance(u, MyABC)
# This used to crash # This used to crash
self.assertRaises(TypeError, MyABC.a.__set__, u, 3) self.assertRaises(TypeError, MyABC.a.__set__, u, 3)
@ -2025,7 +2025,7 @@ def delx(self):
self.assertFalse(hasattr(a, "x")) self.assertFalse(hasattr(a, "x"))
raw = C.__dict__['x'] raw = C.__dict__['x']
self.assertTrue(isinstance(raw, property)) self.assertIsInstance(raw, property)
attrs = dir(raw) attrs = dir(raw)
self.assertIn("__doc__", attrs) self.assertIn("__doc__", attrs)
@ -4237,29 +4237,29 @@ class C:
pass pass
a = C() a = C()
pa = Proxy(a) pa = Proxy(a)
self.assertTrue(isinstance(a, C)) # Baseline self.assertIsInstance(a, C) # Baseline
self.assertTrue(isinstance(pa, C)) # Test self.assertIsInstance(pa, C) # Test
# Test with a classic subclass # Test with a classic subclass
class D(C): class D(C):
pass pass
a = D() a = D()
pa = Proxy(a) pa = Proxy(a)
self.assertTrue(isinstance(a, C)) # Baseline self.assertIsInstance(a, C) # Baseline
self.assertTrue(isinstance(pa, C)) # Test self.assertIsInstance(pa, C) # Test
# Test with a new-style class # Test with a new-style class
class C(object): class C(object):
pass pass
a = C() a = C()
pa = Proxy(a) pa = Proxy(a)
self.assertTrue(isinstance(a, C)) # Baseline self.assertIsInstance(a, C) # Baseline
self.assertTrue(isinstance(pa, C)) # Test self.assertIsInstance(pa, C) # Test
# Test with a new-style subclass # Test with a new-style subclass
class D(C): class D(C):
pass pass
a = D() a = D()
pa = Proxy(a) pa = Proxy(a)
self.assertTrue(isinstance(a, C)) # Baseline self.assertIsInstance(a, C) # Baseline
self.assertTrue(isinstance(pa, C)) # Test self.assertIsInstance(pa, C) # Test
def test_proxy_super(self): def test_proxy_super(self):
# Testing super() for a proxy object... # Testing super() for a proxy object...

2
Lib/test/test_dict.py
View file

@ -225,7 +225,7 @@ def __new__(cls):
return UserDict.UserDict() return UserDict.UserDict()
ud = mydict.fromkeys('ab') ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None}) self.assertEqual(ud, {'a':None, 'b':None})
self.assertTrue(isinstance(ud, UserDict.UserDict)) self.assertIsInstance(ud, UserDict.UserDict)
self.assertRaises(TypeError, dict.fromkeys) self.assertRaises(TypeError, dict.fromkeys)
class Exc(Exception): pass class Exc(Exception): pass

8
Lib/test/test_dictviews.py
View file

@ -71,17 +71,17 @@ def test_dict_values(self):
def test_dict_repr(self): def test_dict_repr(self):
d = {1: 10, "a": "ABC"} d = {1: 10, "a": "ABC"}
self.assertTrue(isinstance(repr(d), str)) self.assertIsInstance(repr(d), str)
r = repr(d.viewitems()) r = repr(d.viewitems())
self.assertTrue(isinstance(r, str)) self.assertIsInstance(r, str)
self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or
r == "dict_items([(1, 10), ('a', 'ABC')])") r == "dict_items([(1, 10), ('a', 'ABC')])")
r = repr(d.viewkeys()) r = repr(d.viewkeys())
self.assertTrue(isinstance(r, str)) self.assertIsInstance(r, str)
self.assertTrue(r == "dict_keys(['a', 1])" or self.assertTrue(r == "dict_keys(['a', 1])" or
r == "dict_keys([1, 'a'])") r == "dict_keys([1, 'a'])")
r = repr(d.viewvalues()) r = repr(d.viewvalues())
self.assertTrue(isinstance(r, str)) self.assertIsInstance(r, str)
self.assertTrue(r == "dict_values(['ABC', 10])" or self.assertTrue(r == "dict_values(['ABC', 10])" or
r == "dict_values([10, 'ABC'])") r == "dict_values([10, 'ABC'])")

8
Lib/test/test_dummy_thread.py
View file

@ -92,16 +92,16 @@ def test_exit(self):
def test_ident(self): def test_ident(self):
#Test sanity of _thread.get_ident() #Test sanity of _thread.get_ident()
self.assertTrue(isinstance(_thread.get_ident(), int), self.assertIsInstance(_thread.get_ident(), int,
"_thread.get_ident() returned a non-integer") "_thread.get_ident() returned a non-integer")
self.assertTrue(_thread.get_ident() != 0, self.assertTrue(_thread.get_ident() != 0,
"_thread.get_ident() returned 0") "_thread.get_ident() returned 0")
def test_LockType(self): def test_LockType(self):
#Make sure _thread.LockType is the same type as _thread.allocate_locke() #Make sure _thread.LockType is the same type as _thread.allocate_locke()
self.assertTrue(isinstance(_thread.allocate_lock(), _thread.LockType), self.assertIsInstance(_thread.allocate_lock(), _thread.LockType,
"_thread.LockType is not an instance of what is " "_thread.LockType is not an instance of what "
"returned by _thread.allocate_lock()") "is returned by _thread.allocate_lock()")
def test_interrupt_main(self): def test_interrupt_main(self):
#Calling start_new_thread with a function that executes interrupt_main #Calling start_new_thread with a function that executes interrupt_main

14
Lib/test/test_ftplib.py
View file

@ -582,36 +582,36 @@ def tearDown(self):
self.server.stop() self.server.stop()
def test_control_connection(self): def test_control_connection(self):
self.assertFalse(isinstance(self.client.sock, ssl.SSLSocket)) self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
self.client.auth() self.client.auth()
self.assertTrue(isinstance(self.client.sock, ssl.SSLSocket)) self.assertIsInstance(self.client.sock, ssl.SSLSocket)
def test_data_connection(self): def test_data_connection(self):
# clear text # clear text
sock = self.client.transfercmd('list') sock = self.client.transfercmd('list')
self.assertFalse(isinstance(sock, ssl.SSLSocket)) self.assertNotIsInstance(sock, ssl.SSLSocket)
sock.close() sock.close()
self.client.voidresp() self.client.voidresp()
# secured, after PROT P # secured, after PROT P
self.client.prot_p() self.client.prot_p()
sock = self.client.transfercmd('list') sock = self.client.transfercmd('list')
self.assertTrue(isinstance(sock, ssl.SSLSocket)) self.assertIsInstance(sock, ssl.SSLSocket)
sock.close() sock.close()
self.client.voidresp() self.client.voidresp()
# PROT C is issued, the connection must be in cleartext again # PROT C is issued, the connection must be in cleartext again
self.client.prot_c() self.client.prot_c()
sock = self.client.transfercmd('list') sock = self.client.transfercmd('list')
self.assertFalse(isinstance(sock, ssl.SSLSocket)) self.assertNotIsInstance(sock, ssl.SSLSocket)
sock.close() sock.close()
self.client.voidresp() self.client.voidresp()
def test_login(self): def test_login(self):
# login() is supposed to implicitly secure the control connection # login() is supposed to implicitly secure the control connection
self.assertFalse(isinstance(self.client.sock, ssl.SSLSocket)) self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
self.client.login() self.client.login()
self.assertTrue(isinstance(self.client.sock, ssl.SSLSocket)) self.assertIsInstance(self.client.sock, ssl.SSLSocket)
# make sure that AUTH TLS doesn't get issued again # make sure that AUTH TLS doesn't get issued again
self.client.login() self.client.login()

2
Lib/test/test_funcattrs.py
View file

@ -68,7 +68,7 @@ def test_func_closure(self):
a = 12 a = 12
def f(): print a def f(): print a
c = f.func_closure c = f.func_closure
self.assertTrue(isinstance(c, tuple)) self.assertIsInstance(c, tuple)
self.assertEqual(len(c), 1) self.assertEqual(len(c), 1)
# don't have a type object handy # don't have a type object handy
self.assertEqual(c[0].__class__.__name__, "cell") self.assertEqual(c[0].__class__.__name__, "cell")

2
Lib/test/test_future.py
View file

@ -109,7 +109,7 @@ def test_multiple_features(self):
def test_unicode_literals_exec(self): def test_unicode_literals_exec(self):
scope = {} scope = {}
exec "from __future__ import unicode_literals; x = ''" in scope exec "from __future__ import unicode_literals; x = ''" in scope
self.assertTrue(isinstance(scope["x"], unicode)) self.assertIsInstance(scope["x"], unicode)
def test_main(): def test_main():

2
Lib/test/test_future5.py
View file

@ -9,7 +9,7 @@
class TestMultipleFeatures(unittest.TestCase): class TestMultipleFeatures(unittest.TestCase):
def test_unicode_literals(self): def test_unicode_literals(self):
self.assertTrue(isinstance("", unicode)) self.assertIsInstance("", unicode)
def test_print_function(self): def test_print_function(self):
with test_support.captured_output("stderr") as s: with test_support.captured_output("stderr") as s:

8
Lib/test/test_grp.py
View file

@ -12,13 +12,13 @@ def check_value(self, value):
# attributes promised by the docs # attributes promised by the docs
self.assertEqual(len(value), 4) self.assertEqual(len(value), 4)
self.assertEqual(value[0], value.gr_name) self.assertEqual(value[0], value.gr_name)
self.assertTrue(isinstance(value.gr_name, basestring)) self.assertIsInstance(value.gr_name, basestring)
self.assertEqual(value[1], value.gr_passwd) self.assertEqual(value[1], value.gr_passwd)
self.assertTrue(isinstance(value.gr_passwd, basestring)) self.assertIsInstance(value.gr_passwd, basestring)
self.assertEqual(value[2], value.gr_gid) self.assertEqual(value[2], value.gr_gid)
self.assertTrue(isinstance(value.gr_gid, int)) self.assertIsInstance(value.gr_gid, int)
self.assertEqual(value[3], value.gr_mem) self.assertEqual(value[3], value.gr_mem)
self.assertTrue(isinstance(value.gr_mem, list)) self.assertIsInstance(value.gr_mem, list)
def test_values(self): def test_values(self):
entries = grp.getgrall() entries = grp.getgrall()

4
Lib/test/test_hash.py
View file

@ -105,11 +105,11 @@ def test_hashable(self):
objects = (self.default_expected + objects = (self.default_expected +
self.fixed_expected) self.fixed_expected)
for obj in objects: for obj in objects:
self.assertTrue(isinstance(obj, Hashable), repr(obj)) self.assertIsInstance(obj, Hashable)
def test_not_hashable(self): def test_not_hashable(self):
for obj in self.error_expected: for obj in self.error_expected:
self.assertFalse(isinstance(obj, Hashable), repr(obj)) self.assertNotIsInstance(obj, Hashable)
# Issue #4701: Check that some builtin types are correctly hashable # Issue #4701: Check that some builtin types are correctly hashable

10
Lib/test/test_int.py
View file

@ -76,15 +76,15 @@ def test_basic(self):
s = repr(-1-sys.maxint) s = repr(-1-sys.maxint)
x = int(s) x = int(s)
self.assertEqual(x+1, -sys.maxint) self.assertEqual(x+1, -sys.maxint)
self.assertTrue(isinstance(x, int)) self.assertIsInstance(x, int)
# should return long # should return long
self.assertEqual(int(s[1:]), sys.maxint+1) self.assertEqual(int(s[1:]), sys.maxint+1)
# should return long # should return long
x = int(1e100) x = int(1e100)
self.assertTrue(isinstance(x, long)) self.assertIsInstance(x, long)
x = int(-1e100) x = int(-1e100)
self.assertTrue(isinstance(x, long)) self.assertIsInstance(x, long)
# SF bug 434186: 0x80000000/2 != 0x80000000>>1. # SF bug 434186: 0x80000000/2 != 0x80000000>>1.
@ -102,11 +102,11 @@ def test_basic(self):
self.assertRaises(ValueError, int, '123\x00 245', 20) self.assertRaises(ValueError, int, '123\x00 245', 20)
x = int('1' * 600) x = int('1' * 600)
self.assertTrue(isinstance(x, long)) self.assertIsInstance(x, long)
if have_unicode: if have_unicode:
x = int(unichr(0x661) * 600) x = int(unichr(0x661) * 600)
self.assertTrue(isinstance(x, long)) self.assertIsInstance(x, long)
self.assertRaises(TypeError, int, 1, 12) self.assertRaises(TypeError, int, 1, 12)

32
Lib/test/test_io.py
View file

@ -2361,27 +2361,27 @@ class C(unicode):
def test_abcs(self): def test_abcs(self):
# Test the visible base classes are ABCs. # Test the visible base classes are ABCs.
self.assertTrue(isinstance(self.IOBase, abc.ABCMeta)) self.assertIsInstance(self.IOBase, abc.ABCMeta)
self.assertTrue(isinstance(self.RawIOBase, abc.ABCMeta)) self.assertIsInstance(self.RawIOBase, abc.ABCMeta)
self.assertTrue(isinstance(self.BufferedIOBase, abc.ABCMeta)) self.assertIsInstance(self.BufferedIOBase, abc.ABCMeta)
self.assertTrue(isinstance(self.TextIOBase, abc.ABCMeta)) self.assertIsInstance(self.TextIOBase, abc.ABCMeta)
def _check_abc_inheritance(self, abcmodule): def _check_abc_inheritance(self, abcmodule):
with self.open(support.TESTFN, "wb", buffering=0) as f: with self.open(support.TESTFN, "wb", buffering=0) as f:
self.assertTrue(isinstance(f, abcmodule.IOBase)) self.assertIsInstance(f, abcmodule.IOBase)
self.assertTrue(isinstance(f, abcmodule.RawIOBase)) self.assertIsInstance(f, abcmodule.RawIOBase)
self.assertFalse(isinstance(f, abcmodule.BufferedIOBase)) self.assertNotIsInstance(f, abcmodule.BufferedIOBase)
self.assertFalse(isinstance(f, abcmodule.TextIOBase)) self.assertNotIsInstance(f, abcmodule.TextIOBase)
with self.open(support.TESTFN, "wb") as f: with self.open(support.TESTFN, "wb") as f:
self.assertTrue(isinstance(f, abcmodule.IOBase)) self.assertIsInstance(f, abcmodule.IOBase)
self.assertFalse(isinstance(f, abcmodule.RawIOBase)) self.assertNotIsInstance(f, abcmodule.RawIOBase)
self.assertTrue(isinstance(f, abcmodule.BufferedIOBase)) self.assertIsInstance(f, abcmodule.BufferedIOBase)
self.assertFalse(isinstance(f, abcmodule.TextIOBase)) self.assertNotIsInstance(f, abcmodule.TextIOBase)
with self.open(support.TESTFN, "w") as f: with self.open(support.TESTFN, "w") as f:
self.assertTrue(isinstance(f, abcmodule.IOBase)) self.assertIsInstance(f, abcmodule.IOBase)
self.assertFalse(isinstance(f, abcmodule.RawIOBase)) self.assertNotIsInstance(f, abcmodule.RawIOBase)
self.assertFalse(isinstance(f, abcmodule.BufferedIOBase)) self.assertNotIsInstance(f, abcmodule.BufferedIOBase)
self.assertTrue(isinstance(f, abcmodule.TextIOBase)) self.assertIsInstance(f, abcmodule.TextIOBase)
def test_abc_inheritance(self): def test_abc_inheritance(self):
# Test implementations inherit from their respective ABCs # Test implementations inherit from their respective ABCs

4
Lib/test/test_long.py
View file

@ -552,7 +552,7 @@ def test_misc(self):
y = int(x) y = int(x)
except OverflowError: except OverflowError:
self.fail("int(long(sys.maxint) + 1) mustn't overflow") self.fail("int(long(sys.maxint) + 1) mustn't overflow")
self.assertTrue(isinstance(y, long), self.assertIsInstance(y, long,
"int(long(sys.maxint) + 1) should have returned long") "int(long(sys.maxint) + 1) should have returned long")
x = hugeneg_aslong - 1 x = hugeneg_aslong - 1
@ -560,7 +560,7 @@ def test_misc(self):
y = int(x) y = int(x)
except OverflowError: except OverflowError:
self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow") self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow")
self.assertTrue(isinstance(y, long), self.assertIsInstance(y, long,
"int(long(-sys.maxint-1) - 1) should have returned long") "int(long(-sys.maxint-1) - 1) should have returned long")
class long2(long): class long2(long):

8
Lib/test/test_memoryio.py
View file

@ -635,7 +635,7 @@ def test_getstate(self):
state = memio.__getstate__() state = memio.__getstate__()
self.assertEqual(len(state), 3) self.assertEqual(len(state), 3)
bytearray(state[0]) # Check if state[0] supports the buffer interface. bytearray(state[0]) # Check if state[0] supports the buffer interface.
self.assert_(isinstance(state[1], int)) self.assertIsInstance(state[1], int)
self.assert_(isinstance(state[2], dict) or state[2] is None) self.assert_(isinstance(state[2], dict) or state[2] is None)
memio.close() memio.close()
self.assertRaises(ValueError, memio.__getstate__) self.assertRaises(ValueError, memio.__getstate__)
@ -679,9 +679,9 @@ def test_getstate(self):
memio = self.ioclass() memio = self.ioclass()
state = memio.__getstate__() state = memio.__getstate__()
self.assertEqual(len(state), 4) self.assertEqual(len(state), 4)
self.assert_(isinstance(state[0], unicode)) self.assertIsInstance(state[0], unicode)
self.assert_(isinstance(state[1], str)) self.assertIsInstance(state[1], str)
self.assert_(isinstance(state[2], int)) self.assertIsInstance(state[2], int)
self.assert_(isinstance(state[3], dict) or state[3] is None) self.assert_(isinstance(state[3], dict) or state[3] is None)
memio.close() memio.close()
self.assertRaises(ValueError, memio.__getstate__) self.assertRaises(ValueError, memio.__getstate__)

4
Lib/test/test_memoryview.py
View file

@ -28,7 +28,7 @@ def check_getitem_with_type(self, tp):
oldrefcount = sys.getrefcount(b) oldrefcount = sys.getrefcount(b)
m = self._view(b) m = self._view(b)
self.assertEquals(m[0], item(b"a")) self.assertEquals(m[0], item(b"a"))
self.assertTrue(isinstance(m[0], bytes), type(m[0])) self.assertIsInstance(m[0], bytes)
self.assertEquals(m[5], item(b"f")) self.assertEquals(m[5], item(b"f"))
self.assertEquals(m[-1], item(b"f")) self.assertEquals(m[-1], item(b"f"))
self.assertEquals(m[-6], item(b"a")) self.assertEquals(m[-6], item(b"a"))
@ -125,7 +125,7 @@ def test_tobytes(self):
expected = b"".join( expected = b"".join(
self.getitem_type(c) for c in b"abcdef") self.getitem_type(c) for c in b"abcdef")
self.assertEquals(b, expected) self.assertEquals(b, expected)
self.assertTrue(isinstance(b, bytes), type(b)) self.assertIsInstance(b, bytes)
def test_tolist(self): def test_tolist(self):
for tp in self._types: for tp in self._types:

2
Lib/test/test_multiprocessing.py
View file

@ -132,7 +132,7 @@ def test_current(self):
self.assertTrue(current.is_alive()) self.assertTrue(current.is_alive())
self.assertTrue(not current.daemon) self.assertTrue(not current.daemon)
self.assertTrue(isinstance(authkey, bytes)) self.assertIsInstance(authkey, bytes)
self.assertTrue(len(authkey) > 0) self.assertTrue(len(authkey) > 0)
self.assertEqual(current.ident, os.getpid()) self.assertEqual(current.ident, os.getpid())
self.assertEqual(current.exitcode, None) self.assertEqual(current.exitcode, None)

2
Lib/test/test_ntpath.py
View file

@ -125,7 +125,7 @@ def test_normpath(self):
# Issue 5827: Make sure normpath preserves unicode # Issue 5827: Make sure normpath preserves unicode
for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'): for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'):
self.assertTrue(isinstance(ntpath.normpath(path), unicode), self.assertIsInstance(ntpath.normpath(path), unicode,
'normpath() returned str instead of unicode') 'normpath() returned str instead of unicode')
def test_expandvars(self): def test_expandvars(self):

2
Lib/test/test_opcodes.py
View file

@ -64,7 +64,7 @@ def __init__(self, ignore):
try: raise DClass, a try: raise DClass, a
except DClass, v: except DClass, v:
self.assertTrue(isinstance(v, DClass)) self.assertIsInstance(v, DClass)
else: else:
self.fail("no exception") self.fail("no exception")

2
Lib/test/test_optparse.py
View file

@ -348,7 +348,7 @@ def test_add_option_invalid_arguments(self):
def test_get_option(self): def test_get_option(self):
opt1 = self.parser.get_option("-v") opt1 = self.parser.get_option("-v")
self.assertTrue(isinstance(opt1, Option)) self.assertIsInstance(opt1, Option)
self.assertEqual(opt1._short_opts, ["-v", "-n"]) self.assertEqual(opt1._short_opts, ["-v", "-n"])
self.assertEqual(opt1._long_opts, ["--verbose", "--noisy"]) self.assertEqual(opt1._long_opts, ["--verbose", "--noisy"])
self.assertEqual(opt1.action, "store_true") self.assertEqual(opt1.action, "store_true")

2
Lib/test/test_parser.py
View file

@ -33,7 +33,7 @@ def test_flags_passed(self):
code = suite.compile() code = suite.compile()
scope = {} scope = {}
exec code in scope exec code in scope
self.assertTrue(isinstance(scope["x"], unicode)) self.assertIsInstance(scope["x"], unicode)
def check_suite(self, s): def check_suite(self, s):
self.roundtrip(parser.suite, s) self.roundtrip(parser.suite, s)

4
Lib/test/test_posix.py
View file

@ -133,7 +133,7 @@ def test_dup(self):
fp = open(test_support.TESTFN) fp = open(test_support.TESTFN)
try: try:
fd = posix.dup(fp.fileno()) fd = posix.dup(fp.fileno())
self.assertTrue(isinstance(fd, int)) self.assertIsInstance(fd, int)
os.close(fd) os.close(fd)
finally: finally:
fp.close() fp.close()
@ -273,7 +273,7 @@ def test_access(self):
def test_umask(self): def test_umask(self):
if hasattr(posix, 'umask'): if hasattr(posix, 'umask'):
old_mask = posix.umask(0) old_mask = posix.umask(0)
self.assertTrue(isinstance(old_mask, int)) self.assertIsInstance(old_mask, int)
posix.umask(old_mask) posix.umask(old_mask)
def test_strerror(self): def test_strerror(self):

8
Lib/test/test_posixpath.py
View file

@ -335,15 +335,15 @@ def test_expanduser(self):
except ImportError: except ImportError:
pass pass
else: else:
self.assertTrue(isinstance(posixpath.expanduser("~/"), basestring)) self.assertIsInstance(posixpath.expanduser("~/"), basestring)
# if home directory == root directory, this test makes no sense # if home directory == root directory, this test makes no sense
if posixpath.expanduser("~") != '/': if posixpath.expanduser("~") != '/':
self.assertEqual( self.assertEqual(
posixpath.expanduser("~") + "/", posixpath.expanduser("~") + "/",
posixpath.expanduser("~/") posixpath.expanduser("~/")
) )
self.assertTrue(isinstance(posixpath.expanduser("~root/"), basestring)) self.assertIsInstance(posixpath.expanduser("~root/"), basestring)
self.assertTrue(isinstance(posixpath.expanduser("~foo/"), basestring)) self.assertIsInstance(posixpath.expanduser("~foo/"), basestring)
with test_support.EnvironmentVarGuard() as env: with test_support.EnvironmentVarGuard() as env:
env['HOME'] = '/' env['HOME'] = '/'
@ -383,7 +383,7 @@ def test_normpath(self):
# Issue 5827: Make sure normpath preserves unicode # Issue 5827: Make sure normpath preserves unicode
for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'): for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'):
self.assertTrue(isinstance(posixpath.normpath(path), unicode), self.assertIsInstance(posixpath.normpath(path), unicode,
'normpath() returned str instead of unicode') 'normpath() returned str instead of unicode')
self.assertRaises(TypeError, posixpath.normpath) self.assertRaises(TypeError, posixpath.normpath)

6
Lib/test/test_print.py
View file

@ -128,11 +128,11 @@ def write(self, what):
self.assertEqual(u''.join(buf.buf), 'hi nothing\n') self.assertEqual(u''.join(buf.buf), 'hi nothing\n')
buf = Recorder(False) buf = Recorder(False)
print('hi', 'bye', end=u'\n', file=buf) print('hi', 'bye', end=u'\n', file=buf)
self.assertTrue(isinstance(buf.buf[1], unicode)) self.assertIsInstance(buf.buf[1], unicode)
self.assertTrue(isinstance(buf.buf[3], unicode)) self.assertIsInstance(buf.buf[3], unicode)
del buf.buf[:] del buf.buf[:]
print(sep=u'x', file=buf) print(sep=u'x', file=buf)
self.assertTrue(isinstance(buf.buf[-1], unicode)) self.assertIsInstance(buf.buf[-1], unicode)
def test_main(): def test_main():

14
Lib/test/test_pwd.py
View file

@ -13,19 +13,19 @@ def test_values(self):
for e in entries: for e in entries:
self.assertEqual(len(e), 7) self.assertEqual(len(e), 7)
self.assertEqual(e[0], e.pw_name) self.assertEqual(e[0], e.pw_name)
self.assertTrue(isinstance(e.pw_name, basestring)) self.assertIsInstance(e.pw_name, basestring)
self.assertEqual(e[1], e.pw_passwd) self.assertEqual(e[1], e.pw_passwd)
self.assertTrue(isinstance(e.pw_passwd, basestring)) self.assertIsInstance(e.pw_passwd, basestring)
self.assertEqual(e[2], e.pw_uid) self.assertEqual(e[2], e.pw_uid)
self.assertTrue(isinstance(e.pw_uid, int)) self.assertIsInstance(e.pw_uid, int)
self.assertEqual(e[3], e.pw_gid) self.assertEqual(e[3], e.pw_gid)
self.assertTrue(isinstance(e.pw_gid, int)) self.assertIsInstance(e.pw_gid, int)
self.assertEqual(e[4], e.pw_gecos) self.assertEqual(e[4], e.pw_gecos)
self.assertTrue(isinstance(e.pw_gecos, basestring)) self.assertIsInstance(e.pw_gecos, basestring)
self.assertEqual(e[5], e.pw_dir) self.assertEqual(e[5], e.pw_dir)
self.assertTrue(isinstance(e.pw_dir, basestring)) self.assertIsInstance(e.pw_dir, basestring)
self.assertEqual(e[6], e.pw_shell) self.assertEqual(e[6], e.pw_shell)
self.assertTrue(isinstance(e.pw_shell, basestring)) self.assertIsInstance(e.pw_shell, basestring)
# The following won't work, because of duplicate entries # The following won't work, because of duplicate entries
# for one uid # for one uid

4
Lib/test/test_pyclbr.py
View file

@ -92,12 +92,12 @@ def ismethod(oclass, obj, name):
self.assertHasattr(module, name, ignore) self.assertHasattr(module, name, ignore)
py_item = getattr(module, name) py_item = getattr(module, name)
if isinstance(value, pyclbr.Function): if isinstance(value, pyclbr.Function):
self.assertTrue(isinstance(py_item, (FunctionType, BuiltinFunctionType))) self.assertIsInstance(py_item, (FunctionType, BuiltinFunctionType))
if py_item.__module__ != moduleName: if py_item.__module__ != moduleName:
continue # skip functions that came from somewhere else continue # skip functions that came from somewhere else
self.assertEquals(py_item.__module__, value.module) self.assertEquals(py_item.__module__, value.module)
else: else:
self.assertTrue(isinstance(py_item, (ClassType, type))) self.assertIsInstance(py_item, (ClassType, type))
if py_item.__module__ != moduleName: if py_item.__module__ != moduleName:
continue # skip classes that came from somewhere else continue # skip classes that came from somewhere else

58
Lib/test/test_sys.py
View file

@ -181,7 +181,7 @@ def test_getdefaultencoding(self):
if test.test_support.have_unicode: if test.test_support.have_unicode:
self.assertRaises(TypeError, sys.getdefaultencoding, 42) self.assertRaises(TypeError, sys.getdefaultencoding, 42)
# can't check more than the type, as the user might have changed it # can't check more than the type, as the user might have changed it
self.assertTrue(isinstance(sys.getdefaultencoding(), str)) self.assertIsInstance(sys.getdefaultencoding(), str)
# testing sys.settrace() is done in test_trace.py # testing sys.settrace() is done in test_trace.py
# testing sys.setprofile() is done in test_profile.py # testing sys.setprofile() is done in test_profile.py
@ -205,13 +205,13 @@ def test_recursionlimit(self):
def test_getwindowsversion(self): def test_getwindowsversion(self):
if hasattr(sys, "getwindowsversion"): if hasattr(sys, "getwindowsversion"):
v = sys.getwindowsversion() v = sys.getwindowsversion()
self.assertTrue(isinstance(v, tuple)) self.assertIsInstance(v, tuple)
self.assertEqual(len(v), 5) self.assertEqual(len(v), 5)
self.assertTrue(isinstance(v[0], int)) self.assertIsInstance(v[0], int)
self.assertTrue(isinstance(v[1], int)) self.assertIsInstance(v[1], int)
self.assertTrue(isinstance(v[2], int)) self.assertIsInstance(v[2], int)
self.assertTrue(isinstance(v[3], int)) self.assertIsInstance(v[3], int)
self.assertTrue(isinstance(v[4], str)) self.assertIsInstance(v[4], str)
def test_dlopenflags(self): def test_dlopenflags(self):
if hasattr(sys, "setdlopenflags"): if hasattr(sys, "setdlopenflags"):
@ -236,7 +236,7 @@ def test_refcount(self):
del n del n
self.assertEqual(sys.getrefcount(None), c) self.assertEqual(sys.getrefcount(None), c)
if hasattr(sys, "gettotalrefcount"): if hasattr(sys, "gettotalrefcount"):
self.assertTrue(isinstance(sys.gettotalrefcount(), int)) self.assertIsInstance(sys.gettotalrefcount(), int)
def test_getframe(self): def test_getframe(self):
self.assertRaises(TypeError, sys._getframe, 42, 42) self.assertRaises(TypeError, sys._getframe, 42, 42)
@ -332,13 +332,13 @@ def current_frames_without_threads(self):
self.assertTrue(d[0] is sys._getframe()) self.assertTrue(d[0] is sys._getframe())
def test_attributes(self): def test_attributes(self):
self.assertTrue(isinstance(sys.api_version, int)) self.assertIsInstance(sys.api_version, int)
self.assertTrue(isinstance(sys.argv, list)) self.assertIsInstance(sys.argv, list)
self.assertIn(sys.byteorder, ("little", "big")) self.assertIn(sys.byteorder, ("little", "big"))
self.assertTrue(isinstance(sys.builtin_module_names, tuple)) self.assertIsInstance(sys.builtin_module_names, tuple)
self.assertTrue(isinstance(sys.copyright, basestring)) self.assertIsInstance(sys.copyright, basestring)
self.assertTrue(isinstance(sys.exec_prefix, basestring)) self.assertIsInstance(sys.exec_prefix, basestring)
self.assertTrue(isinstance(sys.executable, basestring)) self.assertIsInstance(sys.executable, basestring)
self.assertEqual(len(sys.float_info), 11) self.assertEqual(len(sys.float_info), 11)
self.assertEqual(sys.float_info.radix, 2) self.assertEqual(sys.float_info.radix, 2)
self.assertEqual(len(sys.long_info), 2) self.assertEqual(len(sys.long_info), 2)
@ -346,26 +346,26 @@ def test_attributes(self):
self.assertTrue(sys.long_info.sizeof_digit >= 1) self.assertTrue(sys.long_info.sizeof_digit >= 1)
self.assertEqual(type(sys.long_info.bits_per_digit), int) self.assertEqual(type(sys.long_info.bits_per_digit), int)
self.assertEqual(type(sys.long_info.sizeof_digit), int) self.assertEqual(type(sys.long_info.sizeof_digit), int)
self.assertTrue(isinstance(sys.hexversion, int)) self.assertIsInstance(sys.hexversion, int)
self.assertTrue(isinstance(sys.maxint, int)) self.assertIsInstance(sys.maxint, int)
if test.test_support.have_unicode: if test.test_support.have_unicode:
self.assertTrue(isinstance(sys.maxunicode, int)) self.assertIsInstance(sys.maxunicode, int)
self.assertTrue(isinstance(sys.platform, basestring)) self.assertIsInstance(sys.platform, basestring)
self.assertTrue(isinstance(sys.prefix, basestring)) self.assertIsInstance(sys.prefix, basestring)
self.assertTrue(isinstance(sys.version, basestring)) self.assertIsInstance(sys.version, basestring)
vi = sys.version_info vi = sys.version_info
self.assertTrue(isinstance(vi[:], tuple)) self.assertIsInstance(vi[:], tuple)
self.assertEqual(len(vi), 5) self.assertEqual(len(vi), 5)
self.assertTrue(isinstance(vi[0], int)) self.assertIsInstance(vi[0], int)
self.assertTrue(isinstance(vi[1], int)) self.assertIsInstance(vi[1], int)
self.assertTrue(isinstance(vi[2], int)) self.assertIsInstance(vi[2], int)
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final")) self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertTrue(isinstance(vi[4], int)) self.assertIsInstance(vi[4], int)
self.assertTrue(isinstance(vi.major, int)) self.assertIsInstance(vi.major, int)
self.assertTrue(isinstance(vi.minor, int)) self.assertIsInstance(vi.minor, int)
self.assertTrue(isinstance(vi.micro, int)) self.assertIsInstance(vi.micro, int)
self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final")) self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertTrue(isinstance(vi.serial, int)) self.assertIsInstance(vi.serial, int)
self.assertEqual(vi[0], vi.major) self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor) self.assertEqual(vi[1], vi.minor)
self.assertEqual(vi[2], vi.micro) self.assertEqual(vi[2], vi.micro)

2
Lib/test/test_sysconfig.py
View file

@ -105,7 +105,7 @@ def test_get_path(self):
def test_get_config_vars(self): def test_get_config_vars(self):
cvars = get_config_vars() cvars = get_config_vars()
self.assertTrue(isinstance(cvars, dict)) self.assertIsInstance(cvars, dict)
self.assertTrue(cvars) self.assertTrue(cvars)
def test_get_platform(self): def test_get_platform(self):

7
Lib/test/test_tempfile.py
View file

@ -142,8 +142,7 @@ def test_nonempty_list(self):
self.assertFalse(len(cand) == 0) self.assertFalse(len(cand) == 0)
for c in cand: for c in cand:
self.assertTrue(isinstance(c, basestring), self.assertIsInstance(c, basestring)
"%s is not a string" % c)
def test_wanted_dirs(self): def test_wanted_dirs(self):
# _candidate_tempdir_list contains the expected directories # _candidate_tempdir_list contains the expected directories
@ -184,7 +183,7 @@ class test__get_candidate_names(TC):
def test_retval(self): def test_retval(self):
# _get_candidate_names returns a _RandomNameSequence object # _get_candidate_names returns a _RandomNameSequence object
obj = tempfile._get_candidate_names() obj = tempfile._get_candidate_names()
self.assertTrue(isinstance(obj, tempfile._RandomNameSequence)) self.assertIsInstance(obj, tempfile._RandomNameSequence)
def test_same_thing(self): def test_same_thing(self):
# _get_candidate_names always returns the same object # _get_candidate_names always returns the same object
@ -322,7 +321,7 @@ def test_sane_template(self):
# gettempprefix returns a nonempty prefix string # gettempprefix returns a nonempty prefix string
p = tempfile.gettempprefix() p = tempfile.gettempprefix()
self.assertTrue(isinstance(p, basestring)) self.assertIsInstance(p, basestring)
self.assertTrue(len(p) > 0) self.assertTrue(len(p) > 0)
def test_usable_template(self): def test_usable_template(self):

5
Lib/test/test_textwrap.py
View file

@ -349,9 +349,10 @@ def test_unicode(self):
self.check_wrap(text, 50, [u"Hello there, how are you today?"]) self.check_wrap(text, 50, [u"Hello there, how are you today?"])
self.check_wrap(text, 20, [u"Hello there, how are", "you today?"]) self.check_wrap(text, 20, [u"Hello there, how are", "you today?"])
olines = self.wrapper.wrap(text) olines = self.wrapper.wrap(text)
assert isinstance(olines, list) and isinstance(olines[0], unicode) self.assertIsInstance(olines, list)
self.assertIsInstance(olines[0], unicode)
otext = self.wrapper.fill(text) otext = self.wrapper.fill(text)
assert isinstance(otext, unicode) self.assertIsInstance(otext, unicode)
def test_no_split_at_umlaut(self): def test_no_split_at_umlaut(self):
text = u"Die Empf\xe4nger-Auswahl" text = u"Die Empf\xe4nger-Auswahl"

3
Lib/test/test_threading.py
View file

@ -154,8 +154,7 @@ def f(mutex):
# Wait for the thread to finish. # Wait for the thread to finish.
mutex.acquire() mutex.acquire()
self.assertIn(tid, threading._active) self.assertIn(tid, threading._active)
self.assertTrue(isinstance(threading._active[tid], self.assertIsInstance(threading._active[tid], threading._DummyThread)
threading._DummyThread))
del threading._active[tid] del threading._active[tid]
# PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently) # PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)

6
Lib/test/test_transformer.py
View file

@ -14,11 +14,11 @@ def testMultipleLHS(self):
for s in snippets: for s in snippets:
a = transformer.parse(s) a = transformer.parse(s)
assert isinstance(a, ast.Module) self.assertIsInstance(a, ast.Module)
child1 = a.getChildNodes()[0] child1 = a.getChildNodes()[0]
assert isinstance(child1, ast.Stmt) self.assertIsInstance(child1, ast.Stmt)
child2 = child1.getChildNodes()[0] child2 = child1.getChildNodes()[0]
assert isinstance(child2, ast.Assign) self.assertIsInstance(child2, ast.Assign)
# This actually tests the compiler, but it's a way to assure the ast # This actually tests the compiler, but it's a way to assure the ast
# is correct # is correct

4
Lib/test/test_typechecks.py
View file

@ -79,8 +79,8 @@ def __instancecheck__(self, inst):
def __subclasscheck__(self, cls): def __subclasscheck__(self, cls):
return True return True
class Sub(X): pass class Sub(X): pass
self.assertFalse(isinstance(3, X)) self.assertNotIsInstance(3, X)
self.assertTrue(isinstance(X(), X)) self.assertIsInstance(X(), X)
self.assertFalse(issubclass(int, X)) self.assertFalse(issubclass(int, X))
self.assertTrue(issubclass(Sub, X)) self.assertTrue(issubclass(Sub, X))

52
Lib/test/test_unittest.py
View file

@ -186,7 +186,7 @@ def runTest(self):
self.assertFalse('runTest'.startswith(loader.testMethodPrefix)) self.assertFalse('runTest'.startswith(loader.testMethodPrefix))
suite = loader.loadTestsFromTestCase(Foo) suite = loader.loadTestsFromTestCase(Foo)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [Foo('runTest')]) self.assertEqual(list(suite), [Foo('runTest')])
################################################################ ################################################################
@ -205,7 +205,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
expected = [loader.suiteClass([MyTestCase('test')])] expected = [loader.suiteClass([MyTestCase('test')])]
self.assertEqual(list(suite), expected) self.assertEqual(list(suite), expected)
@ -218,7 +218,7 @@ def test_loadTestsFromModule__no_TestCase_instances(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "This method searches `module` for classes derived from TestCase" # "This method searches `module` for classes derived from TestCase"
@ -232,7 +232,7 @@ class MyTestCase(unittest.TestCase):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [loader.suiteClass()]) self.assertEqual(list(suite), [loader.suiteClass()])
@ -468,7 +468,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testcase_1', m) suite = loader.loadTestsFromName('testcase_1', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
# "The specifier name is a ``dotted name'' that may resolve either to # "The specifier name is a ``dotted name'' that may resolve either to
@ -484,7 +484,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testsuite', m) suite = loader.loadTestsFromName('testsuite', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
@ -499,7 +499,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testcase_1.test', m) suite = loader.loadTestsFromName('testcase_1.test', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
@ -538,7 +538,7 @@ def return_TestSuite():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('return_TestSuite', m) suite = loader.loadTestsFromName('return_TestSuite', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [testcase_1, testcase_2]) self.assertEqual(list(suite), [testcase_1, testcase_2])
# "The specifier name is a ``dotted name'' that may resolve ... to # "The specifier name is a ``dotted name'' that may resolve ... to
@ -552,7 +552,7 @@ def return_TestCase():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('return_TestCase', m) suite = loader.loadTestsFromName('return_TestCase', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [testcase_1]) self.assertEqual(list(suite), [testcase_1])
# "The specifier name is a ``dotted name'' that may resolve ... to # "The specifier name is a ``dotted name'' that may resolve ... to
@ -572,7 +572,7 @@ def return_TestCase():
loader = unittest.TestLoader() loader = unittest.TestLoader()
loader.suiteClass = SubTestSuite loader.suiteClass = SubTestSuite
suite = loader.loadTestsFromName('return_TestCase', m) suite = loader.loadTestsFromName('return_TestCase', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [testcase_1]) self.assertEqual(list(suite), [testcase_1])
# "The specifier name is a ``dotted name'' that may resolve ... to # "The specifier name is a ``dotted name'' that may resolve ... to
@ -592,7 +592,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
loader.suiteClass=SubTestSuite loader.suiteClass=SubTestSuite
suite = loader.loadTestsFromName('testcase_1.test', m) suite = loader.loadTestsFromName('testcase_1.test', m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
@ -632,7 +632,7 @@ def test_loadTestsFromName__module_not_loaded(self):
try: try:
suite = loader.loadTestsFromName(module_name) suite = loader.loadTestsFromName(module_name)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# audioop should now be loaded, thanks to loadTestsFromName() # audioop should now be loaded, thanks to loadTestsFromName()
@ -655,7 +655,7 @@ def test_loadTestsFromNames__empty_name_list(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([]) suite = loader.loadTestsFromNames([])
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "Similar to loadTestsFromName(), but takes a sequence of names rather # "Similar to loadTestsFromName(), but takes a sequence of names rather
@ -670,7 +670,7 @@ def test_loadTestsFromNames__relative_empty_name_list(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([], unittest) suite = loader.loadTestsFromNames([], unittest)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "The specifier name is a ``dotted name'' that may resolve either to # "The specifier name is a ``dotted name'' that may resolve either to
@ -871,7 +871,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testcase_1'], m) suite = loader.loadTestsFromNames(['testcase_1'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
expected = loader.suiteClass([MyTestCase('test')]) expected = loader.suiteClass([MyTestCase('test')])
self.assertEqual(list(suite), [expected]) self.assertEqual(list(suite), [expected])
@ -887,7 +887,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testsuite'], m) suite = loader.loadTestsFromNames(['testsuite'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [m.testsuite]) self.assertEqual(list(suite), [m.testsuite])
@ -902,7 +902,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testcase_1.test'], m) suite = loader.loadTestsFromNames(['testcase_1.test'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
ref_suite = unittest.TestSuite([MyTestCase('test')]) ref_suite = unittest.TestSuite([MyTestCase('test')])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -939,7 +939,7 @@ def return_TestSuite():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['return_TestSuite'], m) suite = loader.loadTestsFromNames(['return_TestSuite'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
expected = unittest.TestSuite([testcase_1, testcase_2]) expected = unittest.TestSuite([testcase_1, testcase_2])
self.assertEqual(list(suite), [expected]) self.assertEqual(list(suite), [expected])
@ -955,7 +955,7 @@ def return_TestCase():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['return_TestCase'], m) suite = loader.loadTestsFromNames(['return_TestCase'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
ref_suite = unittest.TestSuite([testcase_1]) ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -979,7 +979,7 @@ def foo():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['Foo.foo'], m) suite = loader.loadTestsFromNames(['Foo.foo'], m)
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
ref_suite = unittest.TestSuite([testcase_1]) ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -1020,7 +1020,7 @@ def test_loadTestsFromNames__module_not_loaded(self):
try: try:
suite = loader.loadTestsFromNames([module_name]) suite = loader.loadTestsFromNames([module_name])
self.assertTrue(isinstance(suite, loader.suiteClass)) self.assertIsInstance(suite, loader.suiteClass)
self.assertEqual(list(suite), [unittest.TestSuite()]) self.assertEqual(list(suite), [unittest.TestSuite()])
# audioop should now be loaded, thanks to loadTestsFromName() # audioop should now be loaded, thanks to loadTestsFromName()
@ -1798,7 +1798,7 @@ def tearDown():
def test_id(self): def test_id(self):
test = unittest.FunctionTestCase(lambda: None) test = unittest.FunctionTestCase(lambda: None)
self.assertTrue(isinstance(test.id(), basestring)) self.assertIsInstance(test.id(), basestring)
# "Returns a one-line description of the test, or None if no description # "Returns a one-line description of the test, or None if no description
# has been provided. The default implementation of this method returns # has been provided. The default implementation of this method returns
@ -1986,7 +1986,7 @@ def test_1(self):
test_case, formatted_exc = result.failures[0] test_case, formatted_exc = result.failures[0]
self.assertTrue(test_case is test) self.assertTrue(test_case is test)
self.assertTrue(isinstance(formatted_exc, str)) self.assertIsInstance(formatted_exc, str)
# "addError(test, err)" # "addError(test, err)"
# ... # ...
@ -2036,7 +2036,7 @@ def test_1(self):
test_case, formatted_exc = result.errors[0] test_case, formatted_exc = result.errors[0]
self.assertTrue(test_case is test) self.assertTrue(test_case is test)
self.assertTrue(isinstance(formatted_exc, str)) self.assertIsInstance(formatted_exc, str)
### Support code for Test_TestCase ### Support code for Test_TestCase
################################################################ ################################################################
@ -2427,7 +2427,7 @@ class Foo(unittest.TestCase):
def runTest(self): def runTest(self):
pass pass
self.assertTrue(isinstance(Foo().id(), basestring)) self.assertIsInstance(Foo().id(), basestring)
# "If result is omitted or None, a temporary result object is created # "If result is omitted or None, a temporary result object is created
# and used, but is not made available to the caller. As TestCase owns the # and used, but is not made available to the caller. As TestCase owns the
@ -2887,7 +2887,7 @@ def Stub(foo):
with ctx: with ctx:
Stub(v) Stub(v)
e = ctx.exc_value e = ctx.exc_value
self.assertTrue(isinstance(e, ExceptionMock)) self.assertIsInstance(e, ExceptionMock)
self.assertEqual(e.args[0], v) self.assertEqual(e.args[0], v)
def testSynonymAssertMethodNames(self): def testSynonymAssertMethodNames(self):

17
Lib/test/test_urllib.py
View file

@ -66,8 +66,7 @@ def test_readlines(self):
def test_fileno(self): def test_fileno(self):
file_num = self.returned_obj.fileno() file_num = self.returned_obj.fileno()
self.assertTrue(isinstance(file_num, int), self.assertIsInstance(file_num, int, "fileno() did not return an int")
"fileno() did not return an int")
self.assertEqual(os.read(file_num, len(self.text)), self.text, self.assertEqual(os.read(file_num, len(self.text)), self.text,
"Reading on the file descriptor returned by fileno() " "Reading on the file descriptor returned by fileno() "
"did not return the expected text") "did not return the expected text")
@ -78,7 +77,7 @@ def test_close(self):
self.returned_obj.close() self.returned_obj.close()
def test_info(self): def test_info(self):
self.assertTrue(isinstance(self.returned_obj.info(), mimetools.Message)) self.assertIsInstance(self.returned_obj.info(), mimetools.Message)
def test_geturl(self): def test_geturl(self):
self.assertEqual(self.returned_obj.geturl(), self.pathname) self.assertEqual(self.returned_obj.geturl(), self.pathname)
@ -229,9 +228,9 @@ def test_basic(self):
# a headers value is returned. # a headers value is returned.
result = urllib.urlretrieve("file:%s" % test_support.TESTFN) result = urllib.urlretrieve("file:%s" % test_support.TESTFN)
self.assertEqual(result[0], test_support.TESTFN) self.assertEqual(result[0], test_support.TESTFN)
self.assertTrue(isinstance(result[1], mimetools.Message), self.assertIsInstance(result[1], mimetools.Message,
"did not get a mimetools.Message instance as second " "did not get a mimetools.Message instance as "
"returned value") "second returned value")
def test_copy(self): def test_copy(self):
# Test that setting the filename argument works. # Test that setting the filename argument works.
@ -254,9 +253,9 @@ def test_copy(self):
def test_reporthook(self): def test_reporthook(self):
# Make sure that the reporthook works. # Make sure that the reporthook works.
def hooktester(count, block_size, total_size, count_holder=[0]): def hooktester(count, block_size, total_size, count_holder=[0]):
self.assertTrue(isinstance(count, int)) self.assertIsInstance(count, int)
self.assertTrue(isinstance(block_size, int)) self.assertIsInstance(block_size, int)
self.assertTrue(isinstance(total_size, int)) self.assertIsInstance(total_size, int)
self.assertEqual(count, count_holder[0]) self.assertEqual(count, count_holder[0])
count_holder[0] = count_holder[0] + 1 count_holder[0] = count_holder[0] + 1
second_temp = "%s.2" % test_support.TESTFN second_temp = "%s.2" % test_support.TESTFN

4
Lib/test/test_urllib2.py
View file

@ -580,12 +580,12 @@ def test_processors(self):
# *_request # *_request
self.assertEqual((handler, name), calls[i]) self.assertEqual((handler, name), calls[i])
self.assertEqual(len(args), 1) self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], Request)) self.assertIsInstance(args[0], Request)
else: else:
# *_response # *_response
self.assertEqual((handler, name), calls[i]) self.assertEqual((handler, name), calls[i])
self.assertEqual(len(args), 2) self.assertEqual(len(args), 2)
self.assertTrue(isinstance(args[0], Request)) self.assertIsInstance(args[0], Request)
# response from opener.open is None, because there's no # response from opener.open is None, because there's no
# handler that defines http_open to handle it # handler that defines http_open to handle it
self.assertTrue(args[1] is None or self.assertTrue(args[1] is None or

6
Lib/test/test_urllib2_localnet.py
View file

@ -457,9 +457,9 @@ def test_info(self):
try: try:
open_url = urllib2.urlopen("http://localhost:%s" % handler.port) open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
info_obj = open_url.info() info_obj = open_url.info()
self.assertTrue(isinstance(info_obj, mimetools.Message), self.assertIsInstance(info_obj, mimetools.Message,
"object returned by 'info' is not an instance of " "object returned by 'info' is not an "
"mimetools.Message") "instance of mimetools.Message")
self.assertEqual(info_obj.getsubtype(), "plain") self.assertEqual(info_obj.getsubtype(), "plain")
finally: finally:
self.server.stop() self.server.stop()

2
Lib/test/test_urllib2net.py
View file

@ -176,7 +176,7 @@ def _test_urls(self, urls, handlers, retry=True):
if expected_err: if expected_err:
msg = ("Didn't get expected error(s) %s for %s %s, got %s: %s" % msg = ("Didn't get expected error(s) %s for %s %s, got %s: %s" %
(expected_err, url, req, type(err), err)) (expected_err, url, req, type(err), err))
self.assertTrue(isinstance(err, expected_err), msg) self.assertIsInstance(err, expected_err, msg)
else: else:
with test_support.transient_internet(): with test_support.transient_internet():
buf = f.read() buf = f.read()

12
Lib/test/test_urllibnet.py
View file

@ -71,9 +71,9 @@ def test_readlines(self):
# Test both readline and readlines. # Test both readline and readlines.
open_url = self.urlopen("http://www.python.org/") open_url = self.urlopen("http://www.python.org/")
try: try:
self.assertTrue(isinstance(open_url.readline(), basestring), self.assertIsInstance(open_url.readline(), basestring,
"readline did not return a string") "readline did not return a string")
self.assertTrue(isinstance(open_url.readlines(), list), self.assertIsInstance(open_url.readlines(), list,
"readlines did not return a list") "readlines did not return a list")
finally: finally:
open_url.close() open_url.close()
@ -85,9 +85,9 @@ def test_info(self):
info_obj = open_url.info() info_obj = open_url.info()
finally: finally:
open_url.close() open_url.close()
self.assertTrue(isinstance(info_obj, mimetools.Message), self.assertIsInstance(info_obj, mimetools.Message,
"object returned by 'info' is not an instance of " "object returned by 'info' is not an "
"mimetools.Message") "instance of mimetools.Message")
self.assertEqual(info_obj.getsubtype(), "html") self.assertEqual(info_obj.getsubtype(), "html")
def test_geturl(self): def test_geturl(self):
@ -175,7 +175,7 @@ def test_header(self):
# Make sure header returned as 2nd value from urlretrieve is good. # Make sure header returned as 2nd value from urlretrieve is good.
file_location, header = self.urlretrieve("http://www.python.org/") file_location, header = self.urlretrieve("http://www.python.org/")
os.unlink(file_location) os.unlink(file_location)
self.assertTrue(isinstance(header, mimetools.Message), self.assertIsInstance(header, mimetools.Message,
"header is not an instance of mimetools.Message") "header is not an instance of mimetools.Message")

4
Lib/test/test_userdict.py
View file

@ -39,8 +39,8 @@ def test_all(self):
self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5) self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5) self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
self.assertTrue(u1.fromkeys('one two'.split()) is not u1) self.assertTrue(u1.fromkeys('one two'.split()) is not u1)
self.assertTrue(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict)) self.assertIsInstance(u1.fromkeys('one two'.split()), UserDict.UserDict)
self.assertTrue(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict)) self.assertIsInstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict)
# Test __repr__ # Test __repr__
self.assertEqual(str(u0), str(d0)) self.assertEqual(str(u0), str(d0))

2
Lib/test/test_userstring.py
View file

@ -114,7 +114,7 @@ def test_immutable(self):
s = self.type2test("foobar") s = self.type2test("foobar")
s2 = s.immutable() s2 = s.immutable()
self.assertEqual(s, s2) self.assertEqual(s, s2)
self.assertTrue(isinstance(s2, UserString)) self.assertIsInstance(s2, UserString)
def test_iadd(self): def test_iadd(self):
s = self.type2test("foo") s = self.type2test("foo")

6
Lib/test/test_wsgiref.py
View file

@ -179,10 +179,10 @@ def checkDefault(self, key, value, alt=None):
# Check defaulting when empty # Check defaulting when empty
env = {} env = {}
util.setup_testing_defaults(env) util.setup_testing_defaults(env)
if isinstance(value,StringIO): if isinstance(value, StringIO):
self.assertTrue(isinstance(env[key],StringIO)) self.assertIsInstance(env[key], StringIO)
else: else:
self.assertEqual(env[key],value) self.assertEqual(env[key], value)
# Check existing value # Check existing value
env = {key:alt} env = {key:alt}

10
Lib/test/test_xmlrpc.py
View file

@ -81,11 +81,11 @@ def test_bug_1164912 (self):
d = xmlrpclib.DateTime() d = xmlrpclib.DateTime()
((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,), ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
methodresponse=True)) methodresponse=True))
self.assertTrue(isinstance(new_d.value, str)) self.assertIsInstance(new_d.value, str)
# Check that the output of dumps() is still an 8-bit string # Check that the output of dumps() is still an 8-bit string
s = xmlrpclib.dumps((new_d,), methodresponse=True) s = xmlrpclib.dumps((new_d,), methodresponse=True)
self.assertTrue(isinstance(s, str)) self.assertIsInstance(s, str)
def test_newstyle_class(self): def test_newstyle_class(self):
class T(object): class T(object):
@ -175,10 +175,10 @@ def test_default_encoding_issues(self):
items = d.items() items = d.items()
if have_unicode: if have_unicode:
self.assertEquals(s, u"abc \x95") self.assertEquals(s, u"abc \x95")
self.assertTrue(isinstance(s, unicode)) self.assertIsInstance(s, unicode)
self.assertEquals(items, [(u"def \x96", u"ghi \x97")]) self.assertEquals(items, [(u"def \x96", u"ghi \x97")])
self.assertTrue(isinstance(items[0][0], unicode)) self.assertIsInstance(items[0][0], unicode)
self.assertTrue(isinstance(items[0][1], unicode)) self.assertIsInstance(items[0][1], unicode)
else: else:
self.assertEquals(s, "abc \xc2\x95") self.assertEquals(s, "abc \xc2\x95")
self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")]) self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")])

2
Lib/test/test_zipfile.py
View file

@ -593,7 +593,7 @@ def test_unicode_filenames(self):
with zipfile.ZipFile(TESTFN, "w") as zf: with zipfile.ZipFile(TESTFN, "w") as zf:
zf.writestr(u"foo.txt", "Test for unicode filename") zf.writestr(u"foo.txt", "Test for unicode filename")
zf.writestr(u"\xf6.txt", "Test for unicode filename") zf.writestr(u"\xf6.txt", "Test for unicode filename")
self.assertTrue(isinstance(zf.infolist()[0].filename, unicode)) self.assertIsInstance(zf.infolist()[0].filename, unicode)
with zipfile.ZipFile(TESTFN, "r") as zf: with zipfile.ZipFile(TESTFN, "r") as zf:
self.assertEqual(zf.filelist[0].filename, "foo.txt") self.assertEqual(zf.filelist[0].filename, "foo.txt")