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

use assert[Not]In where appropriate

Browse source
This commit is contained in:
Ezio Melotti 2010-01-23 23:04:36 +00:00
parent 8cd0a66a0f
commit aa98058cc4
86 changed files with 622 additions and 599 deletions
Download patch file Download diff file Expand all files Collapse all files

29
Lib/test/mapping_tests.py
View file

@ -57,10 +57,10 @@ def test_read(self):
#has_key #has_key
for k in self.reference: for k in self.reference:
self.assertTrue(d.has_key(k)) self.assertTrue(d.has_key(k))
self.assertTrue(k in d) self.assertIn(k, d)
for k in self.other: for k in self.other:
self.assertFalse(d.has_key(k)) self.assertFalse(d.has_key(k))
self.assertFalse(k in d) self.assertNotIn(k, d)
#cmp #cmp
self.assertEqual(cmp(p,p), 0) self.assertEqual(cmp(p,p), 0)
self.assertEqual(cmp(d,d), 0) self.assertEqual(cmp(d,d), 0)
@ -84,7 +84,7 @@ def check_iterandlist(iter, lst, ref):
knownkey, knownvalue = self.other.iteritems().next() knownkey, knownvalue = self.other.iteritems().next()
self.assertEqual(d.get(key, knownvalue), value) self.assertEqual(d.get(key, knownvalue), value)
self.assertEqual(d.get(knownkey, knownvalue), knownvalue) self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
self.assertFalse(knownkey in d) self.assertNotIn(knownkey, d)
def test_write(self): def test_write(self):
# Test for write operations on mapping # Test for write operations on mapping
@ -114,16 +114,16 @@ def test_write(self):
self.assertEqual(d[knownkey], knownvalue) self.assertEqual(d[knownkey], knownvalue)
#pop #pop
self.assertEqual(d.pop(knownkey), knownvalue) self.assertEqual(d.pop(knownkey), knownvalue)
self.assertFalse(knownkey in d) self.assertNotIn(knownkey, d)
self.assertRaises(KeyError, d.pop, knownkey) self.assertRaises(KeyError, d.pop, knownkey)
default = 909 default = 909
d[knownkey] = knownvalue d[knownkey] = knownvalue
self.assertEqual(d.pop(knownkey, default), knownvalue) self.assertEqual(d.pop(knownkey, default), knownvalue)
self.assertFalse(knownkey in d) self.assertNotIn(knownkey, d)
self.assertEqual(d.pop(knownkey, default), default) self.assertEqual(d.pop(knownkey, default), default)
#popitem #popitem
key, value = d.popitem() key, value = d.popitem()
self.assertFalse(key in d) self.assertNotIn(key, d)
self.assertEqual(value, self.reference[key]) self.assertEqual(value, self.reference[key])
p=self._empty_mapping() p=self._empty_mapping()
self.assertRaises(KeyError, p.popitem) self.assertRaises(KeyError, p.popitem)
@ -141,8 +141,8 @@ def test_keys(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assertEqual(d.keys(), []) self.assertEqual(d.keys(), [])
d = self.reference d = self.reference
self.assertTrue(self.inmapping.keys()[0] in d.keys()) self.assertIn(self.inmapping.keys()[0], d.keys())
self.assertTrue(self.other.keys()[0] not in d.keys()) self.assertNotIn(self.other.keys()[0], d.keys())
self.assertRaises(TypeError, d.keys, None) self.assertRaises(TypeError, d.keys, None)
def test_values(self): def test_values(self):
@ -318,9 +318,9 @@ def test_keys(self):
self.assertEqual(d.keys(), []) self.assertEqual(d.keys(), [])
d = self._full_mapping({'a': 1, 'b': 2}) d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys() k = d.keys()
self.assertTrue('a' in k) self.assertIn('a', k)
self.assertTrue('b' in k) self.assertIn('b', k)
self.assertTrue('c' not in k) self.assertNotIn('c', k)
def test_values(self): def test_values(self):
BasicTestMappingProtocol.test_values(self) BasicTestMappingProtocol.test_values(self)
@ -345,12 +345,13 @@ def test_has_key(self):
def test_contains(self): def test_contains(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assertNotIn('a', d)
self.assertTrue(not ('a' in d)) self.assertTrue(not ('a' in d))
self.assertTrue('a' not in d) self.assertTrue('a' not in d)
d = self._full_mapping({'a': 1, 'b': 2}) d = self._full_mapping({'a': 1, 'b': 2})
self.assertTrue('a' in d) self.assertIn('a', d)
self.assertTrue('b' in d) self.assertIn('b', d)
self.assertTrue('c' not in d) self.assertNotIn('c', d)
self.assertRaises(TypeError, d.__contains__) self.assertRaises(TypeError, d.__contains__)

8
Lib/test/pickletester.py
View file

@ -767,8 +767,8 @@ def produce_global_ext(self, extcode, opcode):
# Dump using protocol 1 for comparison. # Dump using protocol 1 for comparison.
s1 = self.dumps(x, 1) s1 = self.dumps(x, 1)
self.assertTrue(__name__ in s1) self.assertIn(__name__, s1)
self.assertTrue("MyList" in s1) self.assertIn("MyList", s1)
self.assertEqual(opcode_in_pickle(opcode, s1), False) self.assertEqual(opcode_in_pickle(opcode, s1), False)
y = self.loads(s1) y = self.loads(s1)
@ -777,8 +777,8 @@ def produce_global_ext(self, extcode, opcode):
# Dump using protocol 2 for test. # Dump using protocol 2 for test.
s2 = self.dumps(x, 2) s2 = self.dumps(x, 2)
self.assertTrue(__name__ not in s2) self.assertNotIn(__name__, s2)
self.assertTrue("MyList" not in s2) self.assertNotIn("MyList", s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True) self.assertEqual(opcode_in_pickle(opcode, s2), True)
y = self.loads(s2) y = self.loads(s2)

10
Lib/test/seq_tests.py
View file

@ -201,9 +201,9 @@ def test_getslice(self):
def test_contains(self): def test_contains(self):
u = self.type2test([0, 1, 2]) u = self.type2test([0, 1, 2])
for i in u: for i in u:
self.assert_(i in u) self.assertIn(i, u)
for i in min(u)-1, max(u)+1: for i in min(u)-1, max(u)+1:
self.assert_(i not in u) self.assertNotIn(i, u)
self.assertRaises(TypeError, u.__contains__) self.assertRaises(TypeError, u.__contains__)
@ -215,8 +215,8 @@ class AllEq:
def __eq__(self, other): def __eq__(self, other):
return True return True
__hash__ = None # Can't meet hash invariant requirements __hash__ = None # Can't meet hash invariant requirements
self.assert_(AllEq() not in self.type2test([])) self.assertNotIn(AllEq(), self.type2test([]))
self.assert_(AllEq() in self.type2test([1])) self.assertIn(AllEq(), self.type2test([1]))
def test_contains_order(self): def test_contains_order(self):
# Sequences must test in-order. If a rich comparison has side # Sequences must test in-order. If a rich comparison has side
@ -229,7 +229,7 @@ def __eq__(self, other):
raise DoNotTestEq raise DoNotTestEq
checkfirst = self.type2test([1, StopCompares()]) checkfirst = self.type2test([1, StopCompares()])
self.assert_(1 in checkfirst) self.assertIn(1, checkfirst)
checklast = self.type2test([StopCompares(), 1]) checklast = self.type2test([StopCompares(), 1])
self.assertRaises(DoNotTestEq, checklast.__contains__, 1) self.assertRaises(DoNotTestEq, checklast.__contains__, 1)

22
Lib/test/test_bigmem.py
View file

@ -580,12 +580,12 @@ def test_contains(self, size):
edge = '-' * (size // 2) edge = '-' * (size // 2)
s = ''.join([edge, SUBSTR, edge]) s = ''.join([edge, SUBSTR, edge])
del edge del edge
self.assertTrue(SUBSTR in s) self.assertIn(SUBSTR, s)
self.assertFalse(SUBSTR * 2 in s) self.assertNotIn(SUBSTR * 2, s)
self.assertTrue('-' in s) self.assertIn('-', s)
self.assertFalse('a' in s) self.assertNotIn('a', s)
s += 'a' s += 'a'
self.assertTrue('a' in s) self.assertIn('a', s)
@bigmemtest(minsize=_2G + 10, memuse=2) @bigmemtest(minsize=_2G + 10, memuse=2)
def test_compare(self, size): def test_compare(self, size):
@ -659,9 +659,9 @@ def test_concat_large(self, size):
def test_contains(self, size): def test_contains(self, size):
t = (1, 2, 3, 4, 5) * size t = (1, 2, 3, 4, 5) * size
self.assertEquals(len(t), size * 5) self.assertEquals(len(t), size * 5)
self.assertTrue(5 in t) self.assertIn(5, t)
self.assertFalse((1, 2, 3, 4, 5) in t) self.assertNotIn((1, 2, 3, 4, 5), t)
self.assertFalse(0 in t) self.assertNotIn(0, t)
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size): def test_hash(self, size):
@ -808,9 +808,9 @@ def test_inplace_concat_large(self, size):
def test_contains(self, size): def test_contains(self, size):
l = [1, 2, 3, 4, 5] * size l = [1, 2, 3, 4, 5] * size
self.assertEquals(len(l), size * 5) self.assertEquals(len(l), size * 5)
self.assertTrue(5 in l) self.assertIn(5, l)
self.assertFalse([1, 2, 3, 4, 5] in l) self.assertNotIn([1, 2, 3, 4, 5], l)
self.assertFalse(0 in l) self.assertNotIn(0, l)
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size): def test_hash(self, size):

22
Lib/test/test_bsddb.py
View file

@ -43,8 +43,8 @@ def test_len(self):
def test_change(self): def test_change(self):
self.f['r'] = 'discovered' self.f['r'] = 'discovered'
self.assertEqual(self.f['r'], 'discovered') self.assertEqual(self.f['r'], 'discovered')
self.assertTrue('r' in self.f.keys()) self.assertIn('r', self.f.keys())
self.assertTrue('discovered' in self.f.values()) self.assertIn('discovered', self.f.values())
def test_close_and_reopen(self): def test_close_and_reopen(self):
if self.fname is None: if self.fname is None:
@ -195,8 +195,8 @@ def test_set_location(self):
def test_contains(self): def test_contains(self):
for k in self.d: for k in self.d:
self.assertTrue(k in self.f) self.assertIn(k, self.f)
self.assertTrue('not here' not in self.f) self.assertNotIn('not here', self.f)
def test_has_key(self): def test_has_key(self):
for k in self.d: for k in self.d:
@ -253,9 +253,9 @@ def test__no_deadlock_first(self, debug=0):
if debug: print "K" if debug: print "K"
# test the legacy cursor interface mixed with writes # test the legacy cursor interface mixed with writes
self.assertTrue(self.f.first()[0] in self.d) self.assertIn(self.f.first()[0], self.d)
k = self.f.next()[0] k = self.f.next()[0]
self.assertTrue(k in self.d) self.assertIn(k, self.d)
self.f[k] = "be gone with ye deadlocks" self.f[k] = "be gone with ye deadlocks"
self.assertTrue(self.f[k], "be gone with ye deadlocks") self.assertTrue(self.f[k], "be gone with ye deadlocks")
@ -279,17 +279,17 @@ def test_for_cursor_memleak(self):
def test_popitem(self): def test_popitem(self):
k, v = self.f.popitem() k, v = self.f.popitem()
self.assertTrue(k in self.d) self.assertIn(k, self.d)
self.assertTrue(v in self.d.values()) self.assertIn(v, self.d.values())
self.assertTrue(k not in self.f) self.assertNotIn(k, self.f)
self.assertEqual(len(self.d)-1, len(self.f)) self.assertEqual(len(self.d)-1, len(self.f))
def test_pop(self): def test_pop(self):
k = 'w' k = 'w'
v = self.f.pop(k) v = self.f.pop(k)
self.assertEqual(v, self.d[k]) self.assertEqual(v, self.d[k])
self.assertTrue(k not in self.f) self.assertNotIn(k, self.f)
self.assertTrue(v not in self.f.values()) self.assertNotIn(v, self.f.values())
self.assertEqual(len(self.d)-1, len(self.f)) self.assertEqual(len(self.d)-1, len(self.f))
def test_get(self): def test_get(self):

28
Lib/test/test_builtin.py
View file

@ -236,11 +236,11 @@ def test_dir(self):
# dir() - local scope # dir() - local scope
local_var = 1 local_var = 1
self.assertTrue('local_var' in dir()) self.assertIn('local_var', dir())
# dir(module) # dir(module)
import sys import sys
self.assertTrue('exit' in dir(sys)) self.assertIn('exit', dir(sys))
# dir(module_with_invalid__dict__) # dir(module_with_invalid__dict__)
import types import types
@ -250,8 +250,8 @@ class Foo(types.ModuleType):
self.assertRaises(TypeError, dir, f) self.assertRaises(TypeError, dir, f)
# dir(type) # dir(type)
self.assertTrue("strip" in dir(str)) self.assertIn("strip", dir(str))
self.assertTrue("__mro__" not in dir(str)) self.assertNotIn("__mro__", dir(str))
# dir(obj) # dir(obj)
class Foo(object): class Foo(object):
@ -260,13 +260,13 @@ def __init__(self):
self.y = 8 self.y = 8
self.z = 9 self.z = 9
f = Foo() f = Foo()
self.assertTrue("y" in dir(f)) self.assertIn("y", dir(f))
# dir(obj_no__dict__) # dir(obj_no__dict__)
class Foo(object): class Foo(object):
__slots__ = [] __slots__ = []
f = Foo() f = Foo()
self.assertTrue("__repr__" in dir(f)) self.assertIn("__repr__", dir(f))
# dir(obj_no__class__with__dict__) # dir(obj_no__class__with__dict__)
# (an ugly trick to cause getattr(f, "__class__") to fail) # (an ugly trick to cause getattr(f, "__class__") to fail)
@ -275,8 +275,8 @@ class Foo(object):
def __init__(self): def __init__(self):
self.bar = "wow" self.bar = "wow"
f = Foo() f = Foo()
self.assertTrue("__repr__" not in dir(f)) self.assertNotIn("__repr__", dir(f))
self.assertTrue("bar" in dir(f)) self.assertIn("bar", dir(f))
# dir(obj_using __dir__) # dir(obj_using __dir__)
class Foo(object): class Foo(object):
@ -1046,18 +1046,18 @@ def test_range(self):
self.assertEqual(range(a+4, a, -2), [a+4, a+2]) self.assertEqual(range(a+4, a, -2), [a+4, a+2])
seq = range(a, b, c) seq = range(a, b, c)
self.assertTrue(a in seq) self.assertIn(a, seq)
self.assertTrue(b not in seq) self.assertNotIn(b, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = range(b, a, -c) seq = range(b, a, -c)
self.assertTrue(b in seq) self.assertIn(b, seq)
self.assertTrue(a not in seq) self.assertNotIn(a, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = range(-a, -b, -c) seq = range(-a, -b, -c)
self.assertTrue(-a in seq) self.assertIn(-a, seq)
self.assertTrue(-b not in seq) self.assertNotIn(-b, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
self.assertRaises(TypeError, range) self.assertRaises(TypeError, range)

29
Lib/test/test_bytes.py
View file

@ -222,27 +222,26 @@ def test_repeat_1char(self):
def test_contains(self): def test_contains(self):
b = self.type2test(b"abc") b = self.type2test(b"abc")
self.assertTrue(ord('a') in b) self.assertIn(ord('a'), b)
self.assertTrue(int(ord('a')) in b) self.assertIn(int(ord('a')), b)
self.assertFalse(200 in b) self.assertNotIn(200, b)
self.assertFalse(200 in b)
self.assertRaises(ValueError, lambda: 300 in b) self.assertRaises(ValueError, lambda: 300 in b)
self.assertRaises(ValueError, lambda: -1 in b) self.assertRaises(ValueError, lambda: -1 in b)
self.assertRaises(TypeError, lambda: None in b) self.assertRaises(TypeError, lambda: None in b)
self.assertRaises(TypeError, lambda: float(ord('a')) in b) self.assertRaises(TypeError, lambda: float(ord('a')) in b)
self.assertRaises(TypeError, lambda: u"a" in b) self.assertRaises(TypeError, lambda: u"a" in b)
for f in bytes, bytearray: for f in bytes, bytearray:
self.assertTrue(f(b"") in b) self.assertIn(f(b""), b)
self.assertTrue(f(b"a") in b) self.assertIn(f(b"a"), b)
self.assertTrue(f(b"b") in b) self.assertIn(f(b"b"), b)
self.assertTrue(f(b"c") in b) self.assertIn(f(b"c"), b)
self.assertTrue(f(b"ab") in b) self.assertIn(f(b"ab"), b)
self.assertTrue(f(b"bc") in b) self.assertIn(f(b"bc"), b)
self.assertTrue(f(b"abc") in b) self.assertIn(f(b"abc"), b)
self.assertFalse(f(b"ac") in b) self.assertNotIn(f(b"ac"), b)
self.assertFalse(f(b"d") in b) self.assertNotIn(f(b"d"), b)
self.assertFalse(f(b"dab") in b) self.assertNotIn(f(b"dab"), b)
self.assertFalse(f(b"abd") in b) self.assertNotIn(f(b"abd"), b)
def test_fromhex(self): def test_fromhex(self):
self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex)

4
Lib/test/test_cfgparser.py
View file

@ -81,8 +81,8 @@ def test_basic(self):
eq(cf.get('Spaces', 'key with spaces'), 'value') eq(cf.get('Spaces', 'key with spaces'), 'value')
eq(cf.get('Spaces', 'another with spaces'), 'splat!') eq(cf.get('Spaces', 'another with spaces'), 'splat!')
self.assertFalse('__name__' in cf.options("Foo Bar"), self.assertNotIn('__name__', cf.options("Foo Bar"),
'__name__ "option" should not be exposed by the API!') '__name__ "option" should not be exposed by the API!')
# Make sure the right things happen for remove_option(); # Make sure the right things happen for remove_option();
# added to include check for SourceForge bug #123324: # added to include check for SourceForge bug #123324:

6
Lib/test/test_cmd_line.py
View file

@ -23,7 +23,7 @@ def test_directories(self):
def verify_valid_flag(self, cmd_line): def verify_valid_flag(self, cmd_line):
data = self.start_python(cmd_line) data = self.start_python(cmd_line)
self.assertTrue(data == '' or data.endswith('\n')) self.assertTrue(data == '' or data.endswith('\n'))
self.assertTrue('Traceback' not in data) self.assertNotIn('Traceback', data)
def test_optimize(self): def test_optimize(self):
self.verify_valid_flag('-O') self.verify_valid_flag('-O')
@ -39,7 +39,7 @@ def test_site_flag(self):
self.verify_valid_flag('-S') self.verify_valid_flag('-S')
def test_usage(self): def test_usage(self):
self.assertTrue('usage' in self.start_python('-h')) self.assertIn('usage', self.start_python('-h'))
def test_version(self): def test_version(self):
version = 'Python %d.%d' % sys.version_info[:2] version = 'Python %d.%d' % sys.version_info[:2]
@ -72,7 +72,7 @@ def test_run_module_bug1764407(self):
p.stdin.write('exit()\n') p.stdin.write('exit()\n')
data = kill_python(p) data = kill_python(p)
self.assertTrue(data.startswith('1 loop')) self.assertTrue(data.startswith('1 loop'))
self.assertTrue('__main__.Timer' in data) self.assertIn('__main__.Timer', data)
def test_run_code(self): def test_run_code(self):
# Test expected operation of the '-c' switch # Test expected operation of the '-c' switch

8
Lib/test/test_cmd_line_script.py
View file

@ -81,9 +81,9 @@ def _check_script(self, script_name, expected_file,
print printed_file print printed_file
print printed_package print printed_package
print printed_argv0 print printed_argv0
self.assertTrue(printed_file in data) self.assertIn(printed_file, data)
self.assertTrue(printed_package in data) self.assertIn(printed_package, data)
self.assertTrue(printed_argv0 in data) self.assertIn(printed_argv0, data)
def _check_import_error(self, script_name, expected_msg, def _check_import_error(self, script_name, expected_msg,
*cmd_line_switches): *cmd_line_switches):
@ -93,7 +93,7 @@ def _check_import_error(self, script_name, expected_msg,
print 'Output from test script %r:' % script_name print 'Output from test script %r:' % script_name
print data print data
print 'Expected output: %r' % expected_msg print 'Expected output: %r' % expected_msg
self.assertTrue(expected_msg in data) self.assertIn(expected_msg, data)
def test_basic_script(self): def test_basic_script(self):
with temp_dir() as script_dir: with temp_dir() as script_dir:

15
Lib/test/test_collections.py
View file

@ -42,9 +42,9 @@ def test_factory(self):
namedtuple('_', 'a b c') # Test leading underscores in a typename namedtuple('_', 'a b c') # Test leading underscores in a typename
nt = namedtuple('nt', u'the quick brown fox') # check unicode input nt = namedtuple('nt', u'the quick brown fox') # check unicode input
self.assertTrue("u'" not in repr(nt._fields)) self.assertNotIn("u'", repr(nt._fields))
nt = namedtuple('nt', (u'the', u'quick')) # check unicode input nt = namedtuple('nt', (u'the', u'quick')) # check unicode input
self.assertTrue("u'" not in repr(nt._fields)) self.assertNotIn("u'", repr(nt._fields))
self.assertRaises(TypeError, Point._make, [11]) # catch too few args self.assertRaises(TypeError, Point._make, [11]) # catch too few args
self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args
@ -73,8 +73,8 @@ def test_instance(self):
self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument
self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument
self.assertEqual(repr(p), 'Point(x=11, y=22)') self.assertEqual(repr(p), 'Point(x=11, y=22)')
self.assertTrue('__dict__' not in dir(p)) # verify instance has no dict self.assertNotIn('__dict__', dir(p)) # verify instance has no dict
self.assertTrue('__weakref__' not in dir(p)) self.assertNotIn('__weakref__', dir(p))
self.assertEqual(p, Point._make([11, 22])) # test _make classmethod self.assertEqual(p, Point._make([11, 22])) # test _make classmethod
self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute
self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method
@ -533,10 +533,10 @@ def test_basics(self):
self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4)) self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff') self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
self.assertEqual(c.pop('f'), 4) self.assertEqual(c.pop('f'), 4)
self.assertEqual('f' in c, False) self.assertNotIn('f', c)
for i in range(3): for i in range(3):
elem, cnt = c.popitem() elem, cnt = c.popitem()
self.assertEqual(elem in c, False) self.assertNotIn(elem, c)
c.clear() c.clear()
self.assertEqual(c, {}) self.assertEqual(c, {})
self.assertEqual(repr(c), 'Counter()') self.assertEqual(repr(c), 'Counter()')
@ -595,6 +595,7 @@ def test_invariant_for_the_in_operator(self):
c = Counter(a=10, b=-2, c=0) c = Counter(a=10, b=-2, c=0)
for elem in c: for elem in c:
self.assertTrue(elem in c) self.assertTrue(elem in c)
self.assertIn(elem, c)
def test_multiset_operations(self): def test_multiset_operations(self):
# Verify that adding a zero counter will strip zeros and negatives # Verify that adding a zero counter will strip zeros and negatives
@ -693,7 +694,7 @@ def test_delitem(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)] pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
od = OrderedDict(pairs) od = OrderedDict(pairs)
del od['a'] del od['a']
self.assertTrue('a' not in od) self.assertNotIn('a', od)
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
del od['a'] del od['a']
self.assertEqual(list(od.items()), pairs[:2] + pairs[3:]) self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])

24
Lib/test/test_compile.py
View file

@ -378,56 +378,56 @@ def __contains__(self, key):
d[1] += 1 d[1] += 1
self.assertEqual(d[1], 2) self.assertEqual(d[1], 2)
del d[1] del d[1]
self.assertEqual(1 in d, False) self.assertNotIn(1, d)
# Tuple of indices # Tuple of indices
d[1, 1] = 1 d[1, 1] = 1
self.assertEqual(d[1, 1], 1) self.assertEqual(d[1, 1], 1)
d[1, 1] += 1 d[1, 1] += 1
self.assertEqual(d[1, 1], 2) self.assertEqual(d[1, 1], 2)
del d[1, 1] del d[1, 1]
self.assertEqual((1, 1) in d, False) self.assertNotIn((1, 1), d)
# Simple slice # Simple slice
d[1:2] = 1 d[1:2] = 1
self.assertEqual(d[1:2], 1) self.assertEqual(d[1:2], 1)
d[1:2] += 1 d[1:2] += 1
self.assertEqual(d[1:2], 2) self.assertEqual(d[1:2], 2)
del d[1:2] del d[1:2]
self.assertEqual(slice(1, 2) in d, False) self.assertNotIn(slice(1, 2), d)
# Tuple of simple slices # Tuple of simple slices
d[1:2, 1:2] = 1 d[1:2, 1:2] = 1
self.assertEqual(d[1:2, 1:2], 1) self.assertEqual(d[1:2, 1:2], 1)
d[1:2, 1:2] += 1 d[1:2, 1:2] += 1
self.assertEqual(d[1:2, 1:2], 2) self.assertEqual(d[1:2, 1:2], 2)
del d[1:2, 1:2] del d[1:2, 1:2]
self.assertEqual((slice(1, 2), slice(1, 2)) in d, False) self.assertNotIn((slice(1, 2), slice(1, 2)), d)
# Extended slice # Extended slice
d[1:2:3] = 1 d[1:2:3] = 1
self.assertEqual(d[1:2:3], 1) self.assertEqual(d[1:2:3], 1)
d[1:2:3] += 1 d[1:2:3] += 1
self.assertEqual(d[1:2:3], 2) self.assertEqual(d[1:2:3], 2)
del d[1:2:3] del d[1:2:3]
self.assertEqual(slice(1, 2, 3) in d, False) self.assertNotIn(slice(1, 2, 3), d)
# Tuple of extended slices # Tuple of extended slices
d[1:2:3, 1:2:3] = 1 d[1:2:3, 1:2:3] = 1
self.assertEqual(d[1:2:3, 1:2:3], 1) self.assertEqual(d[1:2:3, 1:2:3], 1)
d[1:2:3, 1:2:3] += 1 d[1:2:3, 1:2:3] += 1
self.assertEqual(d[1:2:3, 1:2:3], 2) self.assertEqual(d[1:2:3, 1:2:3], 2)
del d[1:2:3, 1:2:3] del d[1:2:3, 1:2:3]
self.assertEqual((slice(1, 2, 3), slice(1, 2, 3)) in d, False) self.assertNotIn((slice(1, 2, 3), slice(1, 2, 3)), d)
# Ellipsis # Ellipsis
d[...] = 1 d[...] = 1
self.assertEqual(d[...], 1) self.assertEqual(d[...], 1)
d[...] += 1 d[...] += 1
self.assertEqual(d[...], 2) self.assertEqual(d[...], 2)
del d[...] del d[...]
self.assertEqual(Ellipsis in d, False) self.assertNotIn(Ellipsis, d)
# Tuple of Ellipses # Tuple of Ellipses
d[..., ...] = 1 d[..., ...] = 1
self.assertEqual(d[..., ...], 1) self.assertEqual(d[..., ...], 1)
d[..., ...] += 1 d[..., ...] += 1
self.assertEqual(d[..., ...], 2) self.assertEqual(d[..., ...], 2)
del d[..., ...] del d[..., ...]
self.assertEqual((Ellipsis, Ellipsis) in d, False) self.assertNotIn((Ellipsis, Ellipsis), d)
def test_mangling(self): def test_mangling(self):
class A: class A:
@ -437,10 +437,10 @@ def f():
import __mangled_mod import __mangled_mod
import __package__.module import __package__.module
self.assertTrue("_A__mangled" in A.f.func_code.co_varnames) self.assertIn("_A__mangled", A.f.func_code.co_varnames)
self.assertTrue("__not_mangled__" in A.f.func_code.co_varnames) self.assertIn("__not_mangled__", A.f.func_code.co_varnames)
self.assertTrue("_A__mangled_mod" in A.f.func_code.co_varnames) self.assertIn("_A__mangled_mod", A.f.func_code.co_varnames)
self.assertTrue("__package__" in A.f.func_code.co_varnames) self.assertIn("__package__", A.f.func_code.co_varnames)
def test_compile_ast(self): def test_compile_ast(self):
fname = __file__ fname = __file__

2
Lib/test/test_compiler.py
View file

@ -87,7 +87,7 @@ def testDefaultArgs(self):
def testDocstrings(self): def testDocstrings(self):
c = compiler.compile('"doc"', '<string>', 'exec') c = compiler.compile('"doc"', '<string>', 'exec')
self.assertTrue('__doc__' in c.co_names) self.assertIn('__doc__', c.co_names)
c = compiler.compile('def f():\n "doc"', '<string>', 'exec') c = compiler.compile('def f():\n "doc"', '<string>', 'exec')
g = {} g = {}
exec c in g exec c in g

56
Lib/test/test_contains.py
View file

@ -20,57 +20,57 @@ def test_common_tests(self):
a = base_set(1) a = base_set(1)
b = set(1) b = set(1)
c = seq(1) c = seq(1)
self.assertTrue(1 in b) self.assertIn(1, b)
self.assertTrue(0 not in b) self.assertNotIn(0, b)
self.assertTrue(1 in c) self.assertIn(1, c)
self.assertTrue(0 not in c) self.assertNotIn(0, c)
self.assertRaises(TypeError, lambda: 1 in a) self.assertRaises(TypeError, lambda: 1 in a)
self.assertRaises(TypeError, lambda: 1 not in a) self.assertRaises(TypeError, lambda: 1 not in a)
# test char in string # test char in string
self.assertTrue('c' in 'abc') self.assertIn('c', 'abc')
self.assertTrue('d' not in 'abc') self.assertNotIn('d', 'abc')
self.assertTrue('' in '') self.assertIn('', '')
self.assertTrue('' in 'abc') self.assertIn('', 'abc')
self.assertRaises(TypeError, lambda: None in 'abc') self.assertRaises(TypeError, lambda: None in 'abc')
if have_unicode: if have_unicode:
def test_char_in_unicode(self): def test_char_in_unicode(self):
self.assertTrue('c' in unicode('abc')) self.assertIn('c', unicode('abc'))
self.assertTrue('d' not in unicode('abc')) self.assertNotIn('d', unicode('abc'))
self.assertTrue('' in unicode('')) self.assertIn('', unicode(''))
self.assertTrue(unicode('') in '') self.assertIn(unicode(''), '')
self.assertTrue(unicode('') in unicode('')) self.assertIn(unicode(''), unicode(''))
self.assertTrue('' in unicode('abc')) self.assertIn('', unicode('abc'))
self.assertTrue(unicode('') in 'abc') self.assertIn(unicode(''), 'abc')
self.assertTrue(unicode('') in unicode('abc')) self.assertIn(unicode(''), unicode('abc'))
self.assertRaises(TypeError, lambda: None in unicode('abc')) self.assertRaises(TypeError, lambda: None in unicode('abc'))
# test Unicode char in Unicode # test Unicode char in Unicode
self.assertTrue(unicode('c') in unicode('abc')) self.assertIn(unicode('c'), unicode('abc'))
self.assertTrue(unicode('d') not in unicode('abc')) self.assertNotIn(unicode('d'), unicode('abc'))
# test Unicode char in string # test Unicode char in string
self.assertTrue(unicode('c') in 'abc') self.assertIn(unicode('c'), 'abc')
self.assertTrue(unicode('d') not in 'abc') self.assertNotIn(unicode('d'), 'abc')
def test_builtin_sequence_types(self): def test_builtin_sequence_types(self):
# a collection of tests on builtin sequence types # a collection of tests on builtin sequence types
a = range(10) a = range(10)
for i in a: for i in a:
self.assertTrue(i in a) self.assertIn(i, a)
self.assertTrue(16 not in a) self.assertNotIn(16, a)
self.assertTrue(a not in a) self.assertNotIn(a, a)
a = tuple(a) a = tuple(a)
for i in a: for i in a:
self.assertTrue(i in a) self.assertIn(i, a)
self.assertTrue(16 not in a) self.assertNotIn(16, a)
self.assertTrue(a not in a) self.assertNotIn(a, a)
class Deviant1: class Deviant1:
"""Behaves strangely when compared """Behaves strangely when compared
@ -86,7 +86,7 @@ def __cmp__(self, other):
self.aList.remove(14) self.aList.remove(14)
return 1 return 1
self.assertTrue(Deviant1() not in Deviant1.aList) self.assertNotIn(Deviant1(), Deviant1.aList)
class Deviant2: class Deviant2:
"""Behaves strangely when compared """Behaves strangely when compared
@ -99,7 +99,7 @@ def __cmp__(self, other):
raise RuntimeError, "gotcha" raise RuntimeError, "gotcha"
try: try:
self.assertTrue(Deviant2() not in a) self.assertNotIn(Deviant2(), a)
except TypeError: except TypeError:
pass pass

77
Lib/test/test_cookielib.py
View file

@ -505,7 +505,7 @@ def test_expires(self):
self.assertEquals(len(c), 2) self.assertEquals(len(c), 2)
c.clear_session_cookies() c.clear_session_cookies()
self.assertEquals(len(c), 1) self.assertEquals(len(c), 1)
self.assertTrue('spam="bar"' in h) self.assertIn('spam="bar"', h)
# XXX RFC 2965 expiry rules (some apply to V0 too) # XXX RFC 2965 expiry rules (some apply to V0 too)
@ -517,39 +517,39 @@ def test_default_path(self):
c = CookieJar(pol) c = CookieJar(pol)
interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"') interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"')
self.assertTrue("/" in c._cookies["www.acme.com"]) self.assertIn("/", c._cookies["www.acme.com"])
c = CookieJar(pol) c = CookieJar(pol)
interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"') interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"')
self.assertTrue("/" in c._cookies["www.acme.com"]) self.assertIn("/", c._cookies["www.acme.com"])
c = CookieJar(pol) c = CookieJar(pol)
interact_2965(c, "http://www.acme.com/blah/rhubarb", interact_2965(c, "http://www.acme.com/blah/rhubarb",
'eggs="bar"; Version="1"') 'eggs="bar"; Version="1"')
self.assertTrue("/blah/" in c._cookies["www.acme.com"]) self.assertIn("/blah/", c._cookies["www.acme.com"])
c = CookieJar(pol) c = CookieJar(pol)
interact_2965(c, "http://www.acme.com/blah/rhubarb/", interact_2965(c, "http://www.acme.com/blah/rhubarb/",
'eggs="bar"; Version="1"') 'eggs="bar"; Version="1"')
self.assertTrue("/blah/rhubarb/" in c._cookies["www.acme.com"]) self.assertIn("/blah/rhubarb/", c._cookies["www.acme.com"])
# Netscape # Netscape
c = CookieJar() c = CookieJar()
interact_netscape(c, "http://www.acme.com/", 'spam="bar"') interact_netscape(c, "http://www.acme.com/", 'spam="bar"')
self.assertTrue("/" in c._cookies["www.acme.com"]) self.assertIn("/", c._cookies["www.acme.com"])
c = CookieJar() c = CookieJar()
interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"') interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"')
self.assertTrue("/" in c._cookies["www.acme.com"]) self.assertIn("/", c._cookies["www.acme.com"])
c = CookieJar() c = CookieJar()
interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"') interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"')
self.assertTrue("/blah" in c._cookies["www.acme.com"]) self.assertIn("/blah", c._cookies["www.acme.com"])
c = CookieJar() c = CookieJar()
interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"') interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"')
self.assertTrue("/blah/rhubarb" in c._cookies["www.acme.com"]) self.assertIn("/blah/rhubarb", c._cookies["www.acme.com"])
def test_escape_path(self): def test_escape_path(self):
from cookielib import escape_path from cookielib import escape_path
@ -937,21 +937,21 @@ def test_domain_mirror(self):
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, "spam=eggs; Version=1") interact_2965(c, url, "spam=eggs; Version=1")
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue("Domain" not in h, self.assertNotIn("Domain", h,
"absent domain returned with domain present") "absent domain returned with domain present")
c = CookieJar(pol) c = CookieJar(pol)
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com') interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com')
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue('$Domain=".bar.com"' in h, "domain not returned") self.assertIn('$Domain=".bar.com"', h, "domain not returned")
c = CookieJar(pol) c = CookieJar(pol)
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
# note missing initial dot in Domain # note missing initial dot in Domain
interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com') interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com')
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue('$Domain="bar.com"' in h, "domain not returned") self.assertIn('$Domain="bar.com"', h, "domain not returned")
def test_path_mirror(self): def test_path_mirror(self):
from cookielib import CookieJar, DefaultCookiePolicy from cookielib import CookieJar, DefaultCookiePolicy
@ -962,14 +962,13 @@ def test_path_mirror(self):
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, "spam=eggs; Version=1") interact_2965(c, url, "spam=eggs; Version=1")
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue("Path" not in h, self.assertNotIn("Path", h, "absent path returned with path present")
"absent path returned with path present")
c = CookieJar(pol) c = CookieJar(pol)
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Path=/') interact_2965(c, url, 'spam=eggs; Version=1; Path=/')
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue('$Path="/"' in h, "path not returned") self.assertIn('$Path="/"', h, "path not returned")
def test_port_mirror(self): def test_port_mirror(self):
from cookielib import CookieJar, DefaultCookiePolicy from cookielib import CookieJar, DefaultCookiePolicy
@ -980,8 +979,7 @@ def test_port_mirror(self):
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, "spam=eggs; Version=1") interact_2965(c, url, "spam=eggs; Version=1")
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue("Port" not in h, self.assertNotIn("Port", h, "absent port returned with port present")
"absent port returned with port present")
c = CookieJar(pol) c = CookieJar(pol)
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
@ -994,16 +992,16 @@ def test_port_mirror(self):
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Port="80"') interact_2965(c, url, 'spam=eggs; Version=1; Port="80"')
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue('$Port="80"' in h, self.assertIn('$Port="80"', h,
"port with single value not returned with single value") "port with single value not returned with single value")
c = CookieJar(pol) c = CookieJar(pol)
url = "http://foo.bar.com/" url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"') interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"')
h = interact_2965(c, url) h = interact_2965(c, url)
self.assertTrue('$Port="80,8080"' in h, self.assertIn('$Port="80,8080"', h,
"port with multiple values not returned with multiple " "port with multiple values not returned with multiple "
"values") "values")
def test_no_return_comment(self): def test_no_return_comment(self):
from cookielib import CookieJar, DefaultCookiePolicy from cookielib import CookieJar, DefaultCookiePolicy
@ -1179,8 +1177,8 @@ def test_netscape_example_1(self):
c.add_cookie_header(req) c.add_cookie_header(req)
h = req.get_header("Cookie") h = req.get_header("Cookie")
self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
"CUSTOMER=WILE_E_COYOTE" in h) self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo') headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo')
res = FakeResponse(headers, "http://www.acme.com") res = FakeResponse(headers, "http://www.acme.com")
@ -1190,17 +1188,17 @@ def test_netscape_example_1(self):
c.add_cookie_header(req) c.add_cookie_header(req)
h = req.get_header("Cookie") h = req.get_header("Cookie")
self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
"CUSTOMER=WILE_E_COYOTE" in h and self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
"SHIPPING=FEDEX" not in h) self.assertNotIn("SHIPPING=FEDEX", h)
req = Request("http://www.acme.com/foo/") req = Request("http://www.acme.com/foo/")
c.add_cookie_header(req) c.add_cookie_header(req)
h = req.get_header("Cookie") h = req.get_header("Cookie")
self.assertTrue(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
"CUSTOMER=WILE_E_COYOTE" in h and self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
h.startswith("SHIPPING=FEDEX;"))) self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
def test_netscape_example_2(self): def test_netscape_example_2(self):
from cookielib import CookieJar from cookielib import CookieJar
@ -1424,8 +1422,8 @@ def test_ietf_example_2(self):
# the server. # the server.
cookie = interact_2965(c, "http://www.acme.com/acme/parts/") cookie = interact_2965(c, "http://www.acme.com/acme/parts/")
self.assertTrue("Rocket_Launcher_0001" in cookie and self.assertIn("Rocket_Launcher_0001", cookie)
"Riding_Rocket_0023" not in cookie) self.assertNotIn("Riding_Rocket_0023", cookie)
def test_rejection(self): def test_rejection(self):
# Test rejection of Set-Cookie2 responses based on domain, path, port. # Test rejection of Set-Cookie2 responses based on domain, path, port.
@ -1579,11 +1577,11 @@ def save_and_restore(cj, ignore_discard):
new_c = save_and_restore(c, True) new_c = save_and_restore(c, True)
self.assertEquals(len(new_c), 6) # none discarded self.assertEquals(len(new_c), 6) # none discarded
self.assertTrue("name='foo1', value='bar'" in repr(new_c)) self.assertIn("name='foo1', value='bar'", repr(new_c))
new_c = save_and_restore(c, False) new_c = save_and_restore(c, False)
self.assertEquals(len(new_c), 4) # 2 of them discarded on save self.assertEquals(len(new_c), 4) # 2 of them discarded on save
self.assertTrue("name='foo1', value='bar'" in repr(new_c)) self.assertIn("name='foo1', value='bar'", repr(new_c))
def test_netscape_misc(self): def test_netscape_misc(self):
# Some additional Netscape cookies tests. # Some additional Netscape cookies tests.
@ -1621,11 +1619,12 @@ def test_intranet_domains_2965(self):
"foo1=bar; PORT; Discard; Version=1;") "foo1=bar; PORT; Discard; Version=1;")
cookie = interact_2965(c, "http://example/", cookie = interact_2965(c, "http://example/",
'foo2=bar; domain=".local"; Version=1') 'foo2=bar; domain=".local"; Version=1')
self.assertTrue("foo1=bar" in cookie) self.assertIn("foo1=bar", cookie)
interact_2965(c, "http://example/", 'foo3=bar; Version=1') interact_2965(c, "http://example/", 'foo3=bar; Version=1')
cookie = interact_2965(c, "http://example/") cookie = interact_2965(c, "http://example/")
self.assertTrue("foo2=bar" in cookie and len(c) == 3) self.assertIn("foo2=bar", cookie)
self.assertEqual(len(c), 3)
def test_intranet_domains_ns(self): def test_intranet_domains_ns(self):
from cookielib import CookieJar, DefaultCookiePolicy from cookielib import CookieJar, DefaultCookiePolicy
@ -1635,10 +1634,10 @@ def test_intranet_domains_ns(self):
cookie = interact_netscape(c, "http://example/", cookie = interact_netscape(c, "http://example/",
'foo2=bar; domain=.local') 'foo2=bar; domain=.local')
self.assertEquals(len(c), 2) self.assertEquals(len(c), 2)
self.assertTrue("foo1=bar" in cookie) self.assertIn("foo1=bar", cookie)
cookie = interact_netscape(c, "http://example/") cookie = interact_netscape(c, "http://example/")
self.assertTrue("foo2=bar" in cookie) self.assertIn("foo2=bar", cookie)
self.assertEquals(len(c), 2) self.assertEquals(len(c), 2)
def test_empty_path(self): def test_empty_path(self):

2
Lib/test/test_copy.py
View file

@ -622,7 +622,7 @@ class C(object):
x, y = C(), C() x, y = C(), C()
# The underlying containers are decoupled # The underlying containers are decoupled
v[x] = y v[x] = y
self.assertFalse(x in u) self.assertNotIn(x, u)
def test_copy_weakkeydict(self): def test_copy_weakkeydict(self):
self._check_copy_weakdict(weakref.WeakKeyDictionary) self._check_copy_weakdict(weakref.WeakKeyDictionary)

4
Lib/test/test_copy_reg.py
View file

@ -54,7 +54,7 @@ def test_extension_registry(self):
self.assertTrue(copy_reg._extension_registry[mod, func] == code) self.assertTrue(copy_reg._extension_registry[mod, func] == code)
self.assertTrue(copy_reg._inverted_registry[code] == (mod, func)) self.assertTrue(copy_reg._inverted_registry[code] == (mod, func))
# Shouldn't be in the cache. # Shouldn't be in the cache.
self.assertTrue(code not in copy_reg._extension_cache) self.assertNotIn(code, copy_reg._extension_cache)
# Redundant registration should be OK. # Redundant registration should be OK.
copy_reg.add_extension(mod, func, code) # shouldn't blow up copy_reg.add_extension(mod, func, code) # shouldn't blow up
# Conflicting code. # Conflicting code.
@ -81,7 +81,7 @@ def test_extension_registry(self):
e.restore() e.restore()
# Shouldn't be there anymore. # Shouldn't be there anymore.
self.assertTrue((mod, func) not in copy_reg._extension_registry) self.assertNotIn((mod, func), copy_reg._extension_registry)
# The code *may* be in copy_reg._extension_registry, though, if # The code *may* be in copy_reg._extension_registry, though, if
# we happened to pick on a registered code. So don't check for # we happened to pick on a registered code. So don't check for
# that. # that.

2
Lib/test/test_csv.py
View file

@ -935,7 +935,7 @@ def test_delimiters(self):
# given that all three lines in sample3 are equal, # given that all three lines in sample3 are equal,
# I think that any character could have been 'guessed' as the # I think that any character could have been 'guessed' as the
# delimiter, depending on dictionary order # delimiter, depending on dictionary order
self.assertTrue(dialect.delimiter in self.sample3) self.assertIn(dialect.delimiter, self.sample3)
dialect = sniffer.sniff(self.sample3, delimiters="?,") dialect = sniffer.sniff(self.sample3, delimiters="?,")
self.assertEqual(dialect.delimiter, "?") self.assertEqual(dialect.delimiter, "?")
dialect = sniffer.sniff(self.sample3, delimiters="/,") dialect = sniffer.sniff(self.sample3, delimiters="/,")

7
Lib/test/test_datetime.py
View file

@ -141,11 +141,8 @@ def test_harmless_mixed_comparison(self):
self.assertFalse(() == me) self.assertFalse(() == me)
self.assertTrue(() != me) self.assertTrue(() != me)
self.assertTrue(me in [1, 20L, [], me]) self.assertIn(me, [1, 20L, [], me])
self.assertFalse(me not in [1, 20L, [], me]) self.assertIn([], [me, 1, 20L, []])
self.assertTrue([] in [me, 1, 20L, []])
self.assertFalse([] not in [me, 1, 20L, []])
def test_harmful_mixed_comparison(self): def test_harmful_mixed_comparison(self):
me = self.theclass(1, 1, 1) me = self.theclass(1, 1, 1)

4
Lib/test/test_dbm.py
View file

@ -21,9 +21,9 @@ def test_keys(self):
self.d[k] = v self.d[k] = v
self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a)) self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a))
for k, v in a: for k, v in a:
self.assertTrue(k in self.d) self.assertIn(k, self.d)
self.assertEqual(self.d[k], v) self.assertEqual(self.d[k], v)
self.assertTrue('xxx' not in self.d) self.assertNotIn('xxx', self.d)
self.assertRaises(KeyError, lambda: self.d['xxx']) self.assertRaises(KeyError, lambda: self.d['xxx'])
self.d.close() self.d.close()

4
Lib/test/test_decimal.py
View file

@ -1628,8 +1628,8 @@ def test_pickle(self):
self.assertEqual(v1, v2) self.assertEqual(v1, v2)
def test_equality_with_other_types(self): def test_equality_with_other_types(self):
self.assertTrue(Decimal(10) in ['a', 1.0, Decimal(10), (1,2), {}]) self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
self.assertTrue(Decimal(10) not in ['a', 1.0, (1,2), {}]) self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
def test_copy(self): def test_copy(self):
# All copies should be deep # All copies should be deep

16
Lib/test/test_defaultdict.py
View file

@ -31,14 +31,14 @@ def test_basic(self):
self.assertEqual(d2["foo"], 1) self.assertEqual(d2["foo"], 1)
self.assertEqual(d2["bar"], 2) self.assertEqual(d2["bar"], 2)
self.assertEqual(d2[42], []) self.assertEqual(d2[42], [])
self.assertTrue("foo" in d2) self.assertIn("foo", d2)
self.assertTrue("foo" in d2.keys()) self.assertIn("foo", d2.keys())
self.assertTrue("bar" in d2) self.assertIn("bar", d2)
self.assertTrue("bar" in d2.keys()) self.assertIn("bar", d2.keys())
self.assertTrue(42 in d2) self.assertIn(42, d2)
self.assertTrue(42 in d2.keys()) self.assertIn(42, d2.keys())
self.assertTrue(12 not in d2) self.assertNotIn(12, d2)
self.assertTrue(12 not in d2.keys()) self.assertNotIn(12, d2.keys())
d2.default_factory = None d2.default_factory = None
self.assertEqual(d2.default_factory, None) self.assertEqual(d2.default_factory, None)
try: try:

6
Lib/test/test_deque.py
View file

@ -199,9 +199,9 @@ def test_delitem(self):
self.assertEqual(len(d), n-i) self.assertEqual(len(d), n-i)
j = random.randrange(-len(d), len(d)) j = random.randrange(-len(d), len(d))
val = d[j] val = d[j]
self.assertTrue(val in d) self.assertIn(val, d)
del d[j] del d[j]
self.assertTrue(val not in d) self.assertNotIn(val, d)
self.assertEqual(len(d), 0) self.assertEqual(len(d), 0)
def test_reverse(self): def test_reverse(self):
@ -328,7 +328,7 @@ def test_repr(self):
e = eval(repr(d)) e = eval(repr(d))
self.assertEqual(list(d), list(e)) self.assertEqual(list(d), list(e))
d.append(d) d.append(d)
self.assertTrue('...' in repr(d)) self.assertIn('...', repr(d))
def test_print(self): def test_print(self):
d = deque(xrange(200)) d = deque(xrange(200))

52
Lib/test/test_descr.py
View file

@ -527,7 +527,7 @@ def spam(self):
return 42 return 42
self.assertEqual(C.name, 'C') self.assertEqual(C.name, 'C')
self.assertEqual(C.bases, ()) self.assertEqual(C.bases, ())
self.assertTrue('spam' in C.dict) self.assertIn('spam', C.dict)
c = C() c = C()
self.assertEqual(c.spam(), 42) self.assertEqual(c.spam(), 42)
@ -1802,10 +1802,10 @@ def __getitem__(self, i):
# depending on whether this test is run standalone or from a framework. # depending on whether this test is run standalone or from a framework.
self.assertTrue(str(c1).find('C object at ') >= 0) self.assertTrue(str(c1).find('C object at ') >= 0)
self.assertEqual(str(c1), repr(c1)) self.assertEqual(str(c1), repr(c1))
self.assertTrue(-1 not in c1) self.assertNotIn(-1, c1)
for i in range(10): for i in range(10):
self.assertTrue(i in c1) self.assertIn(i, c1)
self.assertFalse(10 in c1) self.assertNotIn(10, c1)
# Test the default behavior for dynamic classes # Test the default behavior for dynamic classes
class D(object): class D(object):
def __getitem__(self, i): def __getitem__(self, i):
@ -1826,10 +1826,10 @@ def __getitem__(self, i):
# depending on whether this test is run standalone or from a framework. # depending on whether this test is run standalone or from a framework.
self.assertTrue(str(d1).find('D object at ') >= 0) self.assertTrue(str(d1).find('D object at ') >= 0)
self.assertEqual(str(d1), repr(d1)) self.assertEqual(str(d1), repr(d1))
self.assertTrue(-1 not in d1) self.assertNotIn(-1, d1)
for i in range(10): for i in range(10):
self.assertTrue(i in d1) self.assertIn(i, d1)
self.assertFalse(10 in d1) self.assertNotIn(10, d1)
# Test overridden behavior for static classes # Test overridden behavior for static classes
class Proxy(object): class Proxy(object):
def __init__(self, x): def __init__(self, x):
@ -1866,10 +1866,10 @@ def __contains__(self, value):
self.assertEqual(str(p0), "Proxy:0") self.assertEqual(str(p0), "Proxy:0")
self.assertEqual(repr(p0), "Proxy(0)") self.assertEqual(repr(p0), "Proxy(0)")
p10 = Proxy(range(10)) p10 = Proxy(range(10))
self.assertFalse(-1 in p10) self.assertNotIn(-1, p10)
for i in range(10): for i in range(10):
self.assertTrue(i in p10) self.assertIn(i, p10)
self.assertFalse(10 in p10) self.assertNotIn(10, p10)
# Test overridden behavior for dynamic classes # Test overridden behavior for dynamic classes
class DProxy(object): class DProxy(object):
def __init__(self, x): def __init__(self, x):
@ -1906,10 +1906,10 @@ def __contains__(self, value):
self.assertEqual(str(p0), "DProxy:0") self.assertEqual(str(p0), "DProxy:0")
self.assertEqual(repr(p0), "DProxy(0)") self.assertEqual(repr(p0), "DProxy(0)")
p10 = DProxy(range(10)) p10 = DProxy(range(10))
self.assertFalse(-1 in p10) self.assertNotIn(-1, p10)
for i in range(10): for i in range(10):
self.assertTrue(i in p10) self.assertIn(i, p10)
self.assertFalse(10 in p10) self.assertNotIn(10, p10)
# Safety test for __cmp__ # Safety test for __cmp__
def unsafecmp(a, b): def unsafecmp(a, b):
@ -2028,10 +2028,10 @@ def delx(self):
self.assertTrue(isinstance(raw, property)) self.assertTrue(isinstance(raw, property))
attrs = dir(raw) attrs = dir(raw)
self.assertTrue("__doc__" in attrs) self.assertIn("__doc__", attrs)
self.assertTrue("fget" in attrs) self.assertIn("fget", attrs)
self.assertTrue("fset" in attrs) self.assertIn("fset", attrs)
self.assertTrue("fdel" in attrs) self.assertIn("fdel", attrs)
self.assertEqual(raw.__doc__, "I'm the x property.") self.assertEqual(raw.__doc__, "I'm the x property.")
self.assertTrue(raw.fget is C.__dict__['getx']) self.assertTrue(raw.fget is C.__dict__['getx'])
@ -2249,7 +2249,7 @@ def Cmethod(self): pass
cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__'] cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__']
self.assertEqual(dir(C), cstuff) self.assertEqual(dir(C), cstuff)
self.assertTrue('im_self' in dir(C.Cmethod)) self.assertIn('im_self', dir(C.Cmethod))
c = C() # c.__doc__ is an odd thing to see here; ditto c.__module__. c = C() # c.__doc__ is an odd thing to see here; ditto c.__module__.
self.assertEqual(dir(c), cstuff) self.assertEqual(dir(c), cstuff)
@ -2257,7 +2257,7 @@ def Cmethod(self): pass
c.cdata = 2 c.cdata = 2
c.cmethod = lambda self: 0 c.cmethod = lambda self: 0
self.assertEqual(dir(c), cstuff + ['cdata', 'cmethod']) self.assertEqual(dir(c), cstuff + ['cdata', 'cmethod'])
self.assertTrue('im_self' in dir(c.Cmethod)) self.assertIn('im_self', dir(c.Cmethod))
class A(C): class A(C):
Adata = 1 Adata = 1
@ -2265,10 +2265,10 @@ def Amethod(self): pass
astuff = ['Adata', 'Amethod'] + cstuff astuff = ['Adata', 'Amethod'] + cstuff
self.assertEqual(dir(A), astuff) self.assertEqual(dir(A), astuff)
self.assertTrue('im_self' in dir(A.Amethod)) self.assertIn('im_self', dir(A.Amethod))
a = A() a = A()
self.assertEqual(dir(a), astuff) self.assertEqual(dir(a), astuff)
self.assertTrue('im_self' in dir(a.Amethod)) self.assertIn('im_self', dir(a.Amethod))
a.adata = 42 a.adata = 42
a.amethod = lambda self: 3 a.amethod = lambda self: 3
self.assertEqual(dir(a), astuff + ['adata', 'amethod']) self.assertEqual(dir(a), astuff + ['adata', 'amethod'])
@ -2287,12 +2287,12 @@ def Cmethod(self): pass
c = C() c = C()
self.assertEqual(interesting(dir(c)), cstuff) self.assertEqual(interesting(dir(c)), cstuff)
self.assertTrue('im_self' in dir(C.Cmethod)) self.assertIn('im_self', dir(C.Cmethod))
c.cdata = 2 c.cdata = 2
c.cmethod = lambda self: 0 c.cmethod = lambda self: 0
self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])
self.assertTrue('im_self' in dir(c.Cmethod)) self.assertIn('im_self', dir(c.Cmethod))
class A(C): class A(C):
Adata = 1 Adata = 1
@ -2300,13 +2300,13 @@ def Amethod(self): pass
astuff = ['Adata', 'Amethod'] + cstuff astuff = ['Adata', 'Amethod'] + cstuff
self.assertEqual(interesting(dir(A)), astuff) self.assertEqual(interesting(dir(A)), astuff)
self.assertTrue('im_self' in dir(A.Amethod)) self.assertIn('im_self', dir(A.Amethod))
a = A() a = A()
self.assertEqual(interesting(dir(a)), astuff) self.assertEqual(interesting(dir(a)), astuff)
a.adata = 42 a.adata = 42
a.amethod = lambda self: 3 a.amethod = lambda self: 3
self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod']) self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod'])
self.assertTrue('im_self' in dir(a.Amethod)) self.assertIn('im_self', dir(a.Amethod))
# Try a module subclass. # Try a module subclass.
import sys import sys
@ -2864,7 +2864,7 @@ def __hash__(self):
self.assertEqual(d[cistr('one')], 1) self.assertEqual(d[cistr('one')], 1)
self.assertEqual(d[cistr('tWo')], 2) self.assertEqual(d[cistr('tWo')], 2)
self.assertEqual(d[cistr('THrEE')], 3) self.assertEqual(d[cistr('THrEE')], 3)
self.assertTrue(cistr('ONe') in d) self.assertIn(cistr('ONe'), d)
self.assertEqual(d.get(cistr('thrEE')), 3) self.assertEqual(d.get(cistr('thrEE')), 3)
def test_classic_comparisons(self): def test_classic_comparisons(self):

11
Lib/test/test_dict.py
View file

@ -67,12 +67,13 @@ def test_has_key(self):
def test_contains(self): def test_contains(self):
d = {} d = {}
self.assertNotIn('a', d)
self.assertTrue(not ('a' in d)) self.assertTrue(not ('a' in d))
self.assertTrue('a' not in d) self.assertTrue('a' not in d)
d = {'a': 1, 'b': 2} d = {'a': 1, 'b': 2}
self.assertTrue('a' in d) self.assertIn('a', d)
self.assertTrue('b' in d) self.assertIn('b', d)
self.assertTrue('c' not in d) self.assertNotIn('c', d)
self.assertRaises(TypeError, d.__contains__) self.assertRaises(TypeError, d.__contains__)
@ -430,8 +431,8 @@ def __missing__(self, key):
d = D({1: 2, 3: 4}) d = D({1: 2, 3: 4})
self.assertEqual(d[1], 2) self.assertEqual(d[1], 2)
self.assertEqual(d[3], 4) self.assertEqual(d[3], 4)
self.assertTrue(2 not in d) self.assertNotIn(2, d)
self.assertTrue(2 not in d.keys()) self.assertNotIn(2, d.keys())
self.assertEqual(d[2], 42) self.assertEqual(d[2], 42)
class E(dict): class E(dict):
def __missing__(self, key): def __missing__(self, key):

22
Lib/test/test_dictviews.py
View file

@ -24,10 +24,10 @@ def test_dict_keys(self):
self.assertNotEqual(keys, set([1, "b"])) self.assertNotEqual(keys, set([1, "b"]))
self.assertNotEqual(keys, set([1])) self.assertNotEqual(keys, set([1]))
self.assertNotEqual(keys, 42) self.assertNotEqual(keys, 42)
self.assert_(1 in keys) self.assertIn(1, keys)
self.assert_("a" in keys) self.assertIn("a", keys)
self.assert_(10 not in keys) self.assertNotIn(10, keys)
self.assert_("Z" not in keys) self.assertNotIn("Z", keys)
self.assertEqual(d.viewkeys(), d.viewkeys()) self.assertEqual(d.viewkeys(), d.viewkeys())
e = {1: 11, "a": "def"} e = {1: 11, "a": "def"}
self.assertEqual(d.viewkeys(), e.viewkeys()) self.assertEqual(d.viewkeys(), e.viewkeys())
@ -44,13 +44,13 @@ def test_dict_items(self):
self.assertNotEqual(items, set([(1, 10), ("a", "def")])) self.assertNotEqual(items, set([(1, 10), ("a", "def")]))
self.assertNotEqual(items, set([(1, 10)])) self.assertNotEqual(items, set([(1, 10)]))
self.assertNotEqual(items, 42) self.assertNotEqual(items, 42)
self.assert_((1, 10) in items) self.assertIn((1, 10), items)
self.assert_(("a", "ABC") in items) self.assertIn(("a", "ABC"), items)
self.assert_((1, 11) not in items) self.assertNotIn((1, 11), items)
self.assert_(1 not in items) self.assertNotIn(1, items)
self.assert_(() not in items) self.assertNotIn((), items)
self.assert_((1,) not in items) self.assertNotIn((1,), items)
self.assert_((1, 2, 3) not in items) self.assertNotIn((1, 2, 3), items)
self.assertEqual(d.viewitems(), d.viewitems()) self.assertEqual(d.viewitems(), d.viewitems())
e = d.copy() e = d.copy()
self.assertEqual(d.viewitems(), e.viewitems()) self.assertEqual(d.viewitems(), e.viewitems())

4
Lib/test/test_dis.py
View file

@ -103,8 +103,8 @@ def do_disassembly_test(self, func, expected):
def test_opmap(self): def test_opmap(self):
self.assertEqual(dis.opmap["STOP_CODE"], 0) self.assertEqual(dis.opmap["STOP_CODE"], 0)
self.assertEqual(dis.opmap["LOAD_CONST"] in dis.hasconst, True) self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
self.assertEqual(dis.opmap["STORE_NAME"] in dis.hasname, True) self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
def test_opname(self): def test_opname(self):
self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST") self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")

54
Lib/test/test_docxmlrpc.py
View file

@ -19,8 +19,8 @@ def server(evt, numrequests):
serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_title("DocXMLRPCServer Test Documentation")
serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_name("DocXMLRPCServer Test Docs")
serv.set_server_documentation( serv.set_server_documentation(
"""This is an XML-RPC server's documentation, but the server can be used by "This is an XML-RPC server's documentation, but the server "
POSTing to /RPC2. Try self.add, too.""") "can be used by POSTing to /RPC2. Try self.add, too.")
# Create and register classes and functions # Create and register classes and functions
class TestClass(object): class TestClass(object):
@ -107,9 +107,9 @@ def test_lambda(self):
self.client.request("GET", "/") self.client.request("GET", "/")
response = self.client.getresponse() response = self.client.getresponse()
self.assertTrue( self.assertIn('<dl><dt><a name="-&lt;lambda&gt;"><strong>'
"""<dl><dt><a name="-&lt;lambda&gt;"><strong>&lt;lambda&gt;</strong></a>(x, y)</dt></dl>""" '&lt;lambda&gt;</strong></a>(x, y)</dt></dl>',
in response.read()) response.read())
def test_autolinking(self): def test_autolinking(self):
"""Test that the server correctly automatically wraps references to PEPS """Test that the server correctly automatically wraps references to PEPS
@ -121,9 +121,17 @@ def test_autolinking(self):
self.client.request("GET", "/") self.client.request("GET", "/")
response = self.client.getresponse() response = self.client.getresponse()
self.assertTrue( # This is ugly ... how can it be made better? self.assertIn(
"""<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd><tt>Add&nbsp;two&nbsp;instances&nbsp;together.&nbsp;This&nbsp;follows&nbsp;<a href="http://www.python.org/dev/peps/pep-0008/">PEP008</a>,&nbsp;but&nbsp;has&nbsp;nothing<br>\nto&nbsp;do&nbsp;with&nbsp;<a href="http://www.rfc-editor.org/rfc/rfc1952.txt">RFC1952</a>.&nbsp;Case&nbsp;should&nbsp;matter:&nbsp;pEp008&nbsp;and&nbsp;rFC1952.&nbsp;&nbsp;Things<br>\nthat&nbsp;start&nbsp;with&nbsp;http&nbsp;and&nbsp;ftp&nbsp;should&nbsp;be&nbsp;auto-linked,&nbsp;too:<br>\n<a href="http://google.com">http://google.com</a>.</tt></dd></dl>""" ('<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd>'
in response.read()) '<tt>Add&nbsp;two&nbsp;instances&nbsp;together.&nbsp;This&nbsp;'
'follows&nbsp;<a href="http://www.python.org/dev/peps/pep-0008/">'
'PEP008</a>,&nbsp;but&nbsp;has&nbsp;nothing<br>\nto&nbsp;do&nbsp;'
'with&nbsp;<a href="http://www.rfc-editor.org/rfc/rfc1952.txt">'
'RFC1952</a>.&nbsp;Case&nbsp;should&nbsp;matter:&nbsp;pEp008&nbsp;'
'and&nbsp;rFC1952.&nbsp;&nbsp;Things<br>\nthat&nbsp;start&nbsp;'
'with&nbsp;http&nbsp;and&nbsp;ftp&nbsp;should&nbsp;be&nbsp;'
'auto-linked,&nbsp;too:<br>\n<a href="http://google.com">'
'http://google.com</a>.</tt></dd></dl>'), response.read())
def test_system_methods(self): def test_system_methods(self):
"""Test the precense of three consecutive system.* methods. """Test the precense of three consecutive system.* methods.
@ -134,9 +142,29 @@ def test_system_methods(self):
self.client.request("GET", "/") self.client.request("GET", "/")
response = self.client.getresponse() response = self.client.getresponse()
self.assertTrue( self.assertIn(
"""<dl><dt><a name="-system.listMethods"><strong>system.listMethods</strong></a>()</dt><dd><tt><a href="#-system.listMethods">system.listMethods</a>()&nbsp;=&gt;&nbsp;[\'add\',&nbsp;\'subtract\',&nbsp;\'multiple\']<br>\n&nbsp;<br>\nReturns&nbsp;a&nbsp;list&nbsp;of&nbsp;the&nbsp;methods&nbsp;supported&nbsp;by&nbsp;the&nbsp;server.</tt></dd></dl>\n <dl><dt><a name="-system.methodHelp"><strong>system.methodHelp</strong></a>(method_name)</dt><dd><tt><a href="#-system.methodHelp">system.methodHelp</a>(\'add\')&nbsp;=&gt;&nbsp;"Adds&nbsp;two&nbsp;integers&nbsp;together"<br>\n&nbsp;<br>\nReturns&nbsp;a&nbsp;string&nbsp;containing&nbsp;documentation&nbsp;for&nbsp;the&nbsp;specified&nbsp;method.</tt></dd></dl>\n <dl><dt><a name="-system.methodSignature"><strong>system.methodSignature</strong></a>(method_name)</dt><dd><tt><a href="#-system.methodSignature">system.methodSignature</a>(\'add\')&nbsp;=&gt;&nbsp;[double,&nbsp;int,&nbsp;int]<br>\n&nbsp;<br>\nReturns&nbsp;a&nbsp;list&nbsp;describing&nbsp;the&nbsp;signature&nbsp;of&nbsp;the&nbsp;method.&nbsp;In&nbsp;the<br>\nabove&nbsp;example,&nbsp;the&nbsp;add&nbsp;method&nbsp;takes&nbsp;two&nbsp;integers&nbsp;as&nbsp;arguments<br>\nand&nbsp;returns&nbsp;a&nbsp;double&nbsp;result.<br>\n&nbsp;<br>\nThis&nbsp;server&nbsp;does&nbsp;NOT&nbsp;support&nbsp;system.methodSignature.</tt></dd></dl>""" ('<dl><dt><a name="-system.listMethods"><strong>system.listMethods'
in response.read()) '</strong></a>()</dt><dd><tt><a href="#-system.listMethods">system'
'.listMethods</a>()&nbsp;=&gt;&nbsp;[\'add\',&nbsp;\'subtract\','
'&nbsp;\'multiple\']<br>\n&nbsp;<br>\nReturns&nbsp;a&nbsp;list'
'&nbsp;of&nbsp;the&nbsp;methods&nbsp;supported&nbsp;by&nbsp;the'
'&nbsp;server.</tt></dd></dl>\n <dl><dt><a name="-system.methodHelp">'
'<strong>system.methodHelp</strong></a>(method_name)</dt><dd><tt>'
'<a href="#-system.methodHelp">system.methodHelp</a>(\'add\')&nbsp;'
'=&gt;&nbsp;"Adds&nbsp;two&nbsp;integers&nbsp;together"<br>\n&nbsp;'
'<br>\nReturns&nbsp;a&nbsp;string&nbsp;containing&nbsp;documentation'
'&nbsp;for&nbsp;the&nbsp;specified&nbsp;method.</tt></dd></dl>\n '
'<dl><dt><a name="-system.methodSignature"><strong>system.'
'methodSignature</strong></a>(method_name)</dt><dd><tt><a href="#-'
'system.methodSignature">system.methodSignature</a>(\'add\')&nbsp;'
'=&gt;&nbsp;[double,&nbsp;int,&nbsp;int]<br>\n&nbsp;<br>\nReturns'
'&nbsp;a&nbsp;list&nbsp;describing&nbsp;the&nbsp;signature&nbsp;of'
'&nbsp;the&nbsp;method.&nbsp;In&nbsp;the<br>\nabove&nbsp;example,'
'&nbsp;the&nbsp;add&nbsp;method&nbsp;takes&nbsp;two&nbsp;integers'
'&nbsp;as&nbsp;arguments<br>\nand&nbsp;returns&nbsp;a&nbsp;double'
'&nbsp;result.<br>\n&nbsp;<br>\nThis&nbsp;server&nbsp;does&nbsp;'
'NOT&nbsp;support&nbsp;system.methodSignature.</tt></dd></dl>'),
response.read())
def test_autolink_dotted_methods(self): def test_autolink_dotted_methods(self):
"""Test that selfdot values are made strong automatically in the """Test that selfdot values are made strong automatically in the
@ -144,8 +172,8 @@ def test_autolink_dotted_methods(self):
self.client.request("GET", "/") self.client.request("GET", "/")
response = self.client.getresponse() response = self.client.getresponse()
self.assertTrue("""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""" in self.assertIn("""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""",
response.read()) response.read())
def test_main(): def test_main():
test_support.run_unittest(DocXMLRPCHTTPGETServer) test_support.run_unittest(DocXMLRPCHTTPGETServer)

4
Lib/test/test_errno.py
View file

@ -28,8 +28,8 @@ class ErrorcodeTests(unittest.TestCase):
def test_attributes_in_errorcode(self): def test_attributes_in_errorcode(self):
for attribute in errno.__dict__.iterkeys(): for attribute in errno.__dict__.iterkeys():
if attribute.isupper(): if attribute.isupper():
self.assertTrue(getattr(errno, attribute) in errno.errorcode, self.assertIn(getattr(errno, attribute), errno.errorcode,
'no %s attr in errno.errorcode' % attribute) 'no %s attr in errno.errorcode' % attribute)
def test_main(): def test_main():

2
Lib/test/test_exceptions.py
View file

@ -428,7 +428,7 @@ def g():
return sys.exc_info() return sys.exc_info()
e, v, tb = g() e, v, tb = g()
self.assertTrue(e is RuntimeError, e) self.assertTrue(e is RuntimeError, e)
self.assertTrue("maximum recursion depth exceeded" in str(v), v) self.assertIn("maximum recursion depth exceeded", str(v))

8
Lib/test/test_float.py
View file

@ -434,10 +434,10 @@ def tearDown(self):
float.__setformat__('float', self.save_formats['float']) float.__setformat__('float', self.save_formats['float'])
def test_getformat(self): def test_getformat(self):
self.assertTrue(float.__getformat__('double') in self.assertIn(float.__getformat__('double'),
['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
self.assertTrue(float.__getformat__('float') in self.assertIn(float.__getformat__('float'),
['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
self.assertRaises(ValueError, float.__getformat__, 'chicken') self.assertRaises(ValueError, float.__getformat__, 'chicken')
self.assertRaises(TypeError, float.__getformat__, 1) self.assertRaises(TypeError, float.__getformat__, 1)

6
Lib/test/test_funcattrs.py
View file

@ -36,14 +36,14 @@ def test_module(self):
def test_dir_includes_correct_attrs(self): def test_dir_includes_correct_attrs(self):
self.b.known_attr = 7 self.b.known_attr = 7
self.assertTrue('known_attr' in dir(self.b), self.assertIn('known_attr', dir(self.b),
"set attributes not in dir listing of method") "set attributes not in dir listing of method")
# Test on underlying function object of method # Test on underlying function object of method
self.f.a.im_func.known_attr = 7 self.f.a.im_func.known_attr = 7
self.assertTrue('known_attr' in dir(self.f.a), self.assertIn('known_attr', dir(self.f.a),
"set attribute on unbound method implementation in " "set attribute on unbound method implementation in "
"class not in dir") "class not in dir")
self.assertTrue('known_attr' in dir(self.fi.a), self.assertIn('known_attr', dir(self.fi.a),
"set attribute on unbound method implementations, " "set attribute on unbound method implementations, "
"should show up in next dir") "should show up in next dir")

2
Lib/test/test_gdbm.py
View file

@ -27,7 +27,7 @@ def test_key_methods(self):
self.assertTrue(self.g.has_key('a')) self.assertTrue(self.g.has_key('a'))
key = self.g.firstkey() key = self.g.firstkey()
while key: while key:
self.assertTrue(key in key_set) self.assertIn(key, key_set)
key_set.remove(key) key_set.remove(key)
key = self.g.nextkey(key) key = self.g.nextkey(key)
self.assertRaises(KeyError, lambda: self.g['xxx']) self.assertRaises(KeyError, lambda: self.g['xxx'])

2
Lib/test/test_glob.py
View file

@ -96,7 +96,7 @@ def test_glob_directory_with_trailing_slash(self):
res = glob.glob(self.tempdir + '*' + os.sep) res = glob.glob(self.tempdir + '*' + os.sep)
self.assertEqual(len(res), 1) self.assertEqual(len(res), 1)
# either of these results are reasonable # either of these results are reasonable
self.assertTrue(res[0] in [self.tempdir, self.tempdir + os.sep]) self.assertIn(res[0], [self.tempdir, self.tempdir + os.sep])
def test_glob_broken_symlinks(self): def test_glob_broken_symlinks(self):
if hasattr(os, 'symlink'): if hasattr(os, 'symlink'):

6
Lib/test/test_import.py
View file

@ -202,7 +202,7 @@ def test_failing_reload(self):
sys.path.insert(0, os.curdir) sys.path.insert(0, os.curdir)
try: try:
mod = __import__(TESTFN) mod = __import__(TESTFN)
self.assertTrue(TESTFN in sys.modules, "expected module in sys.modules") self.assertIn(TESTFN, sys.modules)
self.assertEquals(mod.a, 1, "module has wrong attribute values") self.assertEquals(mod.a, 1, "module has wrong attribute values")
self.assertEquals(mod.b, 2, "module has wrong attribute values") self.assertEquals(mod.b, 2, "module has wrong attribute values")
@ -436,14 +436,14 @@ def check_relative():
ns = dict(__package__='foo', __name__='test.notarealmodule') ns = dict(__package__='foo', __name__='test.notarealmodule')
with check_warnings() as w: with check_warnings() as w:
check_absolute() check_absolute()
self.assertTrue('foo' in str(w.message)) self.assertIn('foo', str(w.message))
self.assertEqual(w.category, RuntimeWarning) self.assertEqual(w.category, RuntimeWarning)
self.assertRaises(SystemError, check_relative) self.assertRaises(SystemError, check_relative)
# Check relative fails with __package__ and __name__ wrong # Check relative fails with __package__ and __name__ wrong
ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule') ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule')
with check_warnings() as w: with check_warnings() as w:
check_absolute() check_absolute()
self.assertTrue('foo' in str(w.message)) self.assertIn('foo', str(w.message))
self.assertEqual(w.category, RuntimeWarning) self.assertEqual(w.category, RuntimeWarning)
self.assertRaises(SystemError, check_relative) self.assertRaises(SystemError, check_relative)
# Check both fail with package set to a non-string # Check both fail with package set to a non-string

100
Lib/test/test_inspect.py
View file

@ -112,8 +112,8 @@ class C(object):
x = C() x = C()
x.a = 42 x.a = 42
members = dict(inspect.getmembers(x)) members = dict(inspect.getmembers(x))
self.assertTrue('a' in members) self.assertIn('a', members)
self.assertTrue('b' not in members) self.assertNotIn('b', members)
def test_isabstract(self): def test_isabstract(self):
from abc import ABCMeta, abstractmethod from abc import ABCMeta, abstractmethod
@ -442,23 +442,23 @@ def m1(self): pass
datablob = '1' datablob = '1'
attrs = attrs_wo_objs(A) attrs = attrs_wo_objs(A)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', A) in attrs, 'missing plain method') self.assertIn(('m', 'method', A), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class B(A): class B(A):
def m(self): pass def m(self): pass
attrs = attrs_wo_objs(B) attrs = attrs_wo_objs(B)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') self.assertIn(('m', 'method', B), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class C(A): class C(A):
@ -466,23 +466,23 @@ def m(self): pass
def c(self): pass def c(self): pass
attrs = attrs_wo_objs(C) attrs = attrs_wo_objs(C)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'method', C) in attrs, 'missing plain method') self.assertIn(('c', 'method', C), attrs, 'missing plain method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', C) in attrs, 'missing plain method') self.assertIn(('m', 'method', C), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class D(B, C): class D(B, C):
def m1(self): pass def m1(self): pass
attrs = attrs_wo_objs(D) attrs = attrs_wo_objs(D)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') self.assertIn(('m', 'method', B), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', D) in attrs, 'missing plain method') self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
# Repeat all that, but w/ new-style classes. # Repeat all that, but w/ new-style classes.
def test_classify_newstyle(self): def test_classify_newstyle(self):
@ -504,24 +504,24 @@ def m1(self): pass
datablob = '1' datablob = '1'
attrs = attrs_wo_objs(A) attrs = attrs_wo_objs(A)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', A) in attrs, 'missing plain method') self.assertIn(('m', 'method', A), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class B(A): class B(A):
def m(self): pass def m(self): pass
attrs = attrs_wo_objs(B) attrs = attrs_wo_objs(B)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') self.assertIn(('m', 'method', B), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class C(A): class C(A):
@ -530,24 +530,24 @@ def m(self): pass
def c(self): pass def c(self): pass
attrs = attrs_wo_objs(C) attrs = attrs_wo_objs(C)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'method', C) in attrs, 'missing plain method') self.assertIn(('c', 'method', C), attrs, 'missing plain method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', C) in attrs, 'missing plain method') self.assertIn(('m', 'method', C), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
class D(B, C): class D(B, C):
def m1(self): pass def m1(self): pass
attrs = attrs_wo_objs(D) attrs = attrs_wo_objs(D)
self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertTrue(('c', 'method', C) in attrs, 'missing plain method') self.assertIn(('c', 'method', C), attrs, 'missing plain method')
self.assertTrue(('p', 'property', A) in attrs, 'missing property') self.assertIn(('p', 'property', A), attrs, 'missing property')
self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') self.assertIn(('m', 'method', B), attrs, 'missing plain method')
self.assertTrue(('m1', 'method', D) in attrs, 'missing plain method') self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') self.assertIn(('datablob', 'data', A), attrs, 'missing data')
def test_main(): def test_main():
run_unittest(TestDecorators, TestRetrievingSourceCode, TestOneliners, run_unittest(TestDecorators, TestRetrievingSourceCode, TestOneliners,

4
Lib/test/test_ioctl.py
View file

@ -24,7 +24,7 @@ def test_ioctl(self):
tty = open("/dev/tty", "r") tty = open("/dev/tty", "r")
r = fcntl.ioctl(tty, termios.TIOCGPGRP, " ") r = fcntl.ioctl(tty, termios.TIOCGPGRP, " ")
rpgrp = struct.unpack("i", r)[0] rpgrp = struct.unpack("i", r)[0]
self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) self.assertIn(rpgrp, ids)
def test_ioctl_mutate(self): def test_ioctl_mutate(self):
import array import array
@ -34,7 +34,7 @@ def test_ioctl_mutate(self):
r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1) r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1)
rpgrp = buf[0] rpgrp = buf[0]
self.assertEquals(r, 0) self.assertEquals(r, 0)
self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) self.assertIn(rpgrp, ids)
def test_ioctl_signed_unsigned_code_param(self): def test_ioctl_signed_unsigned_code_param(self):
if not pty: if not pty:

20
Lib/test/test_iter.py
View file

@ -566,23 +566,23 @@ def test_unicode_join_endcase(self): pass
def test_in_and_not_in(self): def test_in_and_not_in(self):
for sc5 in IteratingSequenceClass(5), SequenceClass(5): for sc5 in IteratingSequenceClass(5), SequenceClass(5):
for i in range(5): for i in range(5):
self.assertTrue(i in sc5) self.assertIn(i, sc5)
for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5: for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5:
self.assertTrue(i not in sc5) self.assertNotIn(i, sc5)
self.assertRaises(TypeError, lambda: 3 in 12) self.assertRaises(TypeError, lambda: 3 in 12)
self.assertRaises(TypeError, lambda: 3 not in map) self.assertRaises(TypeError, lambda: 3 not in map)
d = {"one": 1, "two": 2, "three": 3, 1j: 2j} d = {"one": 1, "two": 2, "three": 3, 1j: 2j}
for k in d: for k in d:
self.assertTrue(k in d) self.assertIn(k, d)
self.assertTrue(k not in d.itervalues()) self.assertNotIn(k, d.itervalues())
for v in d.values(): for v in d.values():
self.assertTrue(v in d.itervalues()) self.assertIn(v, d.itervalues())
self.assertTrue(v not in d) self.assertNotIn(v, d)
for k, v in d.iteritems(): for k, v in d.iteritems():
self.assertTrue((k, v) in d.iteritems()) self.assertIn((k, v), d.iteritems())
self.assertTrue((v, k) not in d.iteritems()) self.assertNotIn((v, k), d.iteritems())
f = open(TESTFN, "w") f = open(TESTFN, "w")
try: try:
@ -593,9 +593,9 @@ def test_in_and_not_in(self):
try: try:
for chunk in "abc": for chunk in "abc":
f.seek(0, 0) f.seek(0, 0)
self.assertTrue(chunk not in f) self.assertNotIn(chunk, f)
f.seek(0, 0) f.seek(0, 0)
self.assertTrue((chunk + "\n") in f) self.assertIn((chunk + "\n"), f)
finally: finally:
f.close() f.close()
try: try:

2
Lib/test/test_itertools.py
View file

@ -1385,7 +1385,7 @@ def __init__(self, newarg=None, *args):
Subclass(newarg=1) Subclass(newarg=1)
except TypeError, err: except TypeError, err:
# we expect type errors because of wrong argument count # we expect type errors because of wrong argument count
self.assertFalse("does not take keyword arguments" in err.args[0]) self.assertNotIn("does not take keyword arguments", err.args[0])
libreftest = """ Doctest for examples in the library reference: libitertools.tex libreftest = """ Doctest for examples in the library reference: libitertools.tex

4
Lib/test/test_mhlib.py
View file

@ -256,7 +256,7 @@ def test_modify(self):
eq = self.assertEquals eq = self.assertEquals
mh.makefolder("dummy1") mh.makefolder("dummy1")
self.assertTrue("dummy1" in mh.listfolders()) self.assertIn("dummy1", mh.listfolders())
path = os.path.join(_mhpath, "dummy1") path = os.path.join(_mhpath, "dummy1")
self.assertTrue(os.path.exists(path)) self.assertTrue(os.path.exists(path))
@ -310,7 +310,7 @@ def create(n):
mh.deletefolder('dummy1') mh.deletefolder('dummy1')
mh.deletefolder('dummy2') mh.deletefolder('dummy2')
self.assertTrue('dummy1' not in mh.listfolders()) self.assertNotIn('dummy1', mh.listfolders())
self.assertTrue(not os.path.exists(path)) self.assertTrue(not os.path.exists(path))
def test_read(self): def test_read(self):

2
Lib/test/test_mimetools.py
View file

@ -31,7 +31,7 @@ def test_boundary(self):
s = set([""]) s = set([""])
for i in xrange(100): for i in xrange(100):
nb = mimetools.choose_boundary() nb = mimetools.choose_boundary()
self.assertTrue(nb not in s) self.assertNotIn(nb, s)
s.add(nb) s.add(nb)
def test_message(self): def test_message(self):

2
Lib/test/test_mmap.py
View file

@ -502,7 +502,7 @@ def test_prot_readonly(self):
def test_error(self): def test_error(self):
self.assertTrue(issubclass(mmap.error, EnvironmentError)) self.assertTrue(issubclass(mmap.error, EnvironmentError))
self.assertTrue("mmap.error" in str(mmap.error)) self.assertIn("mmap.error", str(mmap.error))
def test_io_methods(self): def test_io_methods(self):
data = "0123456789" data = "0123456789"

2
Lib/test/test_multibytecodec.py
View file

@ -222,7 +222,7 @@ def test_g2(self):
self.assertEqual(iso2022jp2.decode('iso2022-jp-2'), uni) self.assertEqual(iso2022jp2.decode('iso2022-jp-2'), uni)
def test_iso2022_jp_g0(self): def test_iso2022_jp_g0(self):
self.assertFalse('\x0e' in u'\N{SOFT HYPHEN}'.encode('iso-2022-jp-2')) self.assertNotIn('\x0e', u'\N{SOFT HYPHEN}'.encode('iso-2022-jp-2'))
for encoding in ('iso-2022-jp-2004', 'iso-2022-jp-3'): for encoding in ('iso-2022-jp-2004', 'iso-2022-jp-3'):
e = u'\u3406'.encode(encoding) e = u'\u3406'.encode(encoding)
self.assertFalse(filter(lambda x: x >= '\x80', e)) self.assertFalse(filter(lambda x: x >= '\x80', e))

16
Lib/test/test_multiprocessing.py
View file

@ -162,7 +162,7 @@ def test_process(self):
self.assertEquals(p.authkey, current.authkey) self.assertEquals(p.authkey, current.authkey)
self.assertEquals(p.is_alive(), False) self.assertEquals(p.is_alive(), False)
self.assertEquals(p.daemon, True) self.assertEquals(p.daemon, True)
self.assertTrue(p not in self.active_children()) self.assertNotIn(p, self.active_children())
self.assertTrue(type(self.active_children()) is list) self.assertTrue(type(self.active_children()) is list)
self.assertEqual(p.exitcode, None) self.assertEqual(p.exitcode, None)
@ -170,7 +170,7 @@ def test_process(self):
self.assertEquals(p.exitcode, None) self.assertEquals(p.exitcode, None)
self.assertEquals(p.is_alive(), True) self.assertEquals(p.is_alive(), True)
self.assertTrue(p in self.active_children()) self.assertIn(p, self.active_children())
self.assertEquals(q.get(), args[1:]) self.assertEquals(q.get(), args[1:])
self.assertEquals(q.get(), kwargs) self.assertEquals(q.get(), kwargs)
@ -183,7 +183,7 @@ def test_process(self):
self.assertEquals(p.exitcode, 0) self.assertEquals(p.exitcode, 0)
self.assertEquals(p.is_alive(), False) self.assertEquals(p.is_alive(), False)
self.assertTrue(p not in self.active_children()) self.assertNotIn(p, self.active_children())
def _test_terminate(self): def _test_terminate(self):
time.sleep(1000) time.sleep(1000)
@ -197,7 +197,7 @@ def test_terminate(self):
p.start() p.start()
self.assertEqual(p.is_alive(), True) self.assertEqual(p.is_alive(), True)
self.assertTrue(p in self.active_children()) self.assertIn(p, self.active_children())
self.assertEqual(p.exitcode, None) self.assertEqual(p.exitcode, None)
p.terminate() p.terminate()
@ -207,7 +207,7 @@ def test_terminate(self):
self.assertTimingAlmostEqual(join.elapsed, 0.0) self.assertTimingAlmostEqual(join.elapsed, 0.0)
self.assertEqual(p.is_alive(), False) self.assertEqual(p.is_alive(), False)
self.assertTrue(p not in self.active_children()) self.assertNotIn(p, self.active_children())
p.join() p.join()
@ -226,13 +226,13 @@ def test_active_children(self):
self.assertEqual(type(self.active_children()), list) self.assertEqual(type(self.active_children()), list)
p = self.Process(target=time.sleep, args=(DELTA,)) p = self.Process(target=time.sleep, args=(DELTA,))
self.assertTrue(p not in self.active_children()) self.assertNotIn(p, self.active_children())
p.start() p.start()
self.assertTrue(p in self.active_children()) self.assertIn(p, self.active_children())
p.join() p.join()
self.assertTrue(p not in self.active_children()) self.assertNotIn(p, self.active_children())
def _test_recursion(self, wconn, id): def _test_recursion(self, wconn, id):
from multiprocessing import forking from multiprocessing import forking

2
Lib/test/test_os.py
View file

@ -198,7 +198,7 @@ def trunc(x): return int(x)
def trunc(x): return x def trunc(x): return x
self.assertEquals(trunc(getattr(result, attr)), self.assertEquals(trunc(getattr(result, attr)),
result[getattr(stat, name)]) result[getattr(stat, name)])
self.assertTrue(attr in members) self.assertIn(attr, members)
try: try:
result[200] result[200]

60
Lib/test/test_peepholer.py
View file

@ -25,8 +25,8 @@ def unot(x):
del x del x
asm = disassemble(unot) asm = disassemble(unot)
for elem in ('UNARY_NOT', 'POP_JUMP_IF_FALSE'): for elem in ('UNARY_NOT', 'POP_JUMP_IF_FALSE'):
self.assertTrue(elem not in asm) self.assertNotIn(elem, asm)
self.assertTrue('POP_JUMP_IF_TRUE' in asm) self.assertIn('POP_JUMP_IF_TRUE', asm)
def test_elim_inversion_of_is_or_in(self): def test_elim_inversion_of_is_or_in(self):
for line, elem in ( for line, elem in (
@ -36,7 +36,7 @@ def test_elim_inversion_of_is_or_in(self):
('not a not in b', '(in)',), ('not a not in b', '(in)',),
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm) self.assertIn(elem, asm)
def test_none_as_constant(self): def test_none_as_constant(self):
# LOAD_GLOBAL None --> LOAD_CONST None # LOAD_GLOBAL None --> LOAD_CONST None
@ -45,14 +45,14 @@ def f(x):
return x return x
asm = disassemble(f) asm = disassemble(f)
for elem in ('LOAD_GLOBAL',): for elem in ('LOAD_GLOBAL',):
self.assertTrue(elem not in asm) self.assertNotIn(elem, asm)
for elem in ('LOAD_CONST', '(None)'): for elem in ('LOAD_CONST', '(None)'):
self.assertTrue(elem in asm) self.assertIn(elem, asm)
def f(): def f():
'Adding a docstring made this test fail in Py2.5.0' 'Adding a docstring made this test fail in Py2.5.0'
return None return None
self.assertTrue('LOAD_CONST' in disassemble(f)) self.assertIn('LOAD_CONST', disassemble(f))
self.assertTrue('LOAD_GLOBAL' not in disassemble(f)) self.assertNotIn('LOAD_GLOBAL', disassemble(f))
def test_while_one(self): def test_while_one(self):
# Skip over: LOAD_CONST trueconst POP_JUMP_IF_FALSE xx # Skip over: LOAD_CONST trueconst POP_JUMP_IF_FALSE xx
@ -62,9 +62,9 @@ def f():
return list return list
asm = disassemble(f) asm = disassemble(f)
for elem in ('LOAD_CONST', 'POP_JUMP_IF_FALSE'): for elem in ('LOAD_CONST', 'POP_JUMP_IF_FALSE'):
self.assertTrue(elem not in asm) self.assertNotIn(elem, asm)
for elem in ('JUMP_ABSOLUTE',): for elem in ('JUMP_ABSOLUTE',):
self.assertTrue(elem in asm) self.assertIn(elem, asm)
def test_pack_unpack(self): def test_pack_unpack(self):
for line, elem in ( for line, elem in (
@ -73,9 +73,9 @@ def test_pack_unpack(self):
('a, b, c = a, b, c', 'ROT_THREE',), ('a, b, c = a, b, c', 'ROT_THREE',),
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm) self.assertIn(elem, asm)
self.assertTrue('BUILD_TUPLE' not in asm) self.assertNotIn('BUILD_TUPLE', asm)
self.assertTrue('UNPACK_TUPLE' not in asm) self.assertNotIn('UNPACK_TUPLE', asm)
def test_folding_of_tuples_of_constants(self): def test_folding_of_tuples_of_constants(self):
for line, elem in ( for line, elem in (
@ -86,8 +86,8 @@ def test_folding_of_tuples_of_constants(self):
('((1, 2), 3, 4)', '(((1, 2), 3, 4))'), ('((1, 2), 3, 4)', '(((1, 2), 3, 4))'),
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm) self.assertIn(elem, asm)
self.assertTrue('BUILD_TUPLE' not in asm) self.assertNotIn('BUILD_TUPLE', asm)
# Bug 1053819: Tuple of constants misidentified when presented with: # Bug 1053819: Tuple of constants misidentified when presented with:
# . . . opcode_with_arg 100 unary_opcode BUILD_TUPLE 1 . . . # . . . opcode_with_arg 100 unary_opcode BUILD_TUPLE 1 . . .
@ -125,17 +125,17 @@ def test_folding_of_binops_on_constants(self):
('a = 13 | 7', '(15)'), # binary or ('a = 13 | 7', '(15)'), # binary or
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm, asm) self.assertIn(elem, asm, asm)
self.assertTrue('BINARY_' not in asm) self.assertNotIn('BINARY_', asm)
# Verify that unfoldables are skipped # Verify that unfoldables are skipped
asm = dis_single('a=2+"b"') asm = dis_single('a=2+"b"')
self.assertTrue('(2)' in asm) self.assertIn('(2)', asm)
self.assertTrue("('b')" in asm) self.assertIn("('b')", asm)
# Verify that large sequences do not result from folding # Verify that large sequences do not result from folding
asm = dis_single('a="x"*1000') asm = dis_single('a="x"*1000')
self.assertTrue('(1000)' in asm) self.assertIn('(1000)', asm)
def test_folding_of_unaryops_on_constants(self): def test_folding_of_unaryops_on_constants(self):
for line, elem in ( for line, elem in (
@ -144,8 +144,8 @@ def test_folding_of_unaryops_on_constants(self):
('~-2', '(1)'), # unary invert ('~-2', '(1)'), # unary invert
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm, asm) self.assertIn(elem, asm, asm)
self.assertTrue('UNARY_' not in asm) self.assertNotIn('UNARY_', asm)
# Verify that unfoldables are skipped # Verify that unfoldables are skipped
for line, elem in ( for line, elem in (
@ -153,16 +153,16 @@ def test_folding_of_unaryops_on_constants(self):
('~"abc"', "('abc')"), # unary invert ('~"abc"', "('abc')"), # unary invert
): ):
asm = dis_single(line) asm = dis_single(line)
self.assertTrue(elem in asm, asm) self.assertIn(elem, asm, asm)
self.assertTrue('UNARY_' in asm) self.assertIn('UNARY_', asm)
def test_elim_extra_return(self): def test_elim_extra_return(self):
# RETURN LOAD_CONST None RETURN --> RETURN # RETURN LOAD_CONST None RETURN --> RETURN
def f(x): def f(x):
return x return x
asm = disassemble(f) asm = disassemble(f)
self.assertTrue('LOAD_CONST' not in asm) self.assertNotIn('LOAD_CONST', asm)
self.assertTrue('(None)' not in asm) self.assertNotIn('(None)', asm)
self.assertEqual(asm.split().count('RETURN_VALUE'), 1) self.assertEqual(asm.split().count('RETURN_VALUE'), 1)
def test_elim_jump_to_return(self): def test_elim_jump_to_return(self):
@ -170,8 +170,8 @@ def test_elim_jump_to_return(self):
def f(cond, true_value, false_value): def f(cond, true_value, false_value):
return true_value if cond else false_value return true_value if cond else false_value
asm = disassemble(f) asm = disassemble(f)
self.assertTrue('JUMP_FORWARD' not in asm) self.assertNotIn('JUMP_FORWARD', asm)
self.assertTrue('JUMP_ABSOLUTE' not in asm) self.assertNotIn('JUMP_ABSOLUTE', asm)
self.assertEqual(asm.split().count('RETURN_VALUE'), 2) self.assertEqual(asm.split().count('RETURN_VALUE'), 2)
def test_elim_jump_after_return1(self): def test_elim_jump_after_return1(self):
@ -186,8 +186,8 @@ def f(cond1, cond2):
return 5 return 5
return 6 return 6
asm = disassemble(f) asm = disassemble(f)
self.assertTrue('JUMP_FORWARD' not in asm) self.assertNotIn('JUMP_FORWARD', asm)
self.assertTrue('JUMP_ABSOLUTE' not in asm) self.assertNotIn('JUMP_ABSOLUTE', asm)
self.assertEqual(asm.split().count('RETURN_VALUE'), 6) self.assertEqual(asm.split().count('RETURN_VALUE'), 6)
def test_elim_jump_after_return2(self): def test_elim_jump_after_return2(self):
@ -196,7 +196,7 @@ def f(cond1, cond2):
while 1: while 1:
if cond1: return 4 if cond1: return 4
asm = disassemble(f) asm = disassemble(f)
self.assertTrue('JUMP_FORWARD' not in asm) self.assertNotIn('JUMP_FORWARD', asm)
# There should be one jump for the while loop. # There should be one jump for the while loop.
self.assertEqual(asm.split().count('JUMP_ABSOLUTE'), 1) self.assertEqual(asm.split().count('JUMP_ABSOLUTE'), 1)
self.assertEqual(asm.split().count('RETURN_VALUE'), 2) self.assertEqual(asm.split().count('RETURN_VALUE'), 2)

4
Lib/test/test_pep352.py
View file

@ -41,7 +41,7 @@ def test_inheritance(self):
last_exc = getattr(__builtin__, superclass_name) last_exc = getattr(__builtin__, superclass_name)
except AttributeError: except AttributeError:
self.fail("base class %s not a built-in" % superclass_name) self.fail("base class %s not a built-in" % superclass_name)
self.assertTrue(superclass_name in exc_set) self.assertIn(superclass_name, exc_set)
exc_set.discard(superclass_name) exc_set.discard(superclass_name)
superclasses = [] # Loop will insert base exception superclasses = [] # Loop will insert base exception
last_depth = 0 last_depth = 0
@ -75,7 +75,7 @@ def test_inheritance(self):
self.verify_instance_interface(exc()) self.verify_instance_interface(exc())
except TypeError: except TypeError:
pass pass
self.assertTrue(exc_name in exc_set) self.assertIn(exc_name, exc_set)
exc_set.discard(exc_name) exc_set.discard(exc_name)
last_exc = exc last_exc = exc
last_depth = depth last_depth = depth

2
Lib/test/test_poplib.py
View file

@ -246,7 +246,7 @@ def setUp(self):
self.client = poplib.POP3_SSL(self.server.host, self.server.port) self.client = poplib.POP3_SSL(self.server.host, self.server.port)
def test__all__(self): def test__all__(self):
self.assertTrue('POP3_SSL' in poplib.__all__) self.assertIn('POP3_SSL', poplib.__all__)
class TestTimeouts(TestCase): class TestTimeouts(TestCase):

2
Lib/test/test_posix.py
View file

@ -264,7 +264,7 @@ def test_chdir(self):
def test_lsdir(self): def test_lsdir(self):
if hasattr(posix, 'lsdir'): if hasattr(posix, 'lsdir'):
self.assertTrue(test_support.TESTFN in posix.lsdir(os.curdir)) self.assertIn(test_support.TESTFN, posix.lsdir(os.curdir))
def test_access(self): def test_access(self):
if hasattr(posix, 'access'): if hasattr(posix, 'access'):

2
Lib/test/test_profile.py
View file

@ -57,7 +57,7 @@ def test_calling_conventions(self):
stats = pstats.Stats(prof, stream=s) stats = pstats.Stats(prof, stream=s)
stats.print_stats() stats.print_stats()
res = s.getvalue() res = s.getvalue()
self.assertTrue(self.expected_list_sort_output in res, self.assertIn(self.expected_list_sort_output, res,
"Profiling {0!r} didn't report list.sort:\n{1}".format(stmt, res)) "Profiling {0!r} didn't report list.sort:\n{1}".format(stmt, res))

4
Lib/test/test_pwd.py
View file

@ -43,8 +43,8 @@ def test_values(self):
for e in entries: for e in entries:
if not e[0] or e[0] == '+': if not e[0] or e[0] == '+':
continue # skip NIS entries etc. continue # skip NIS entries etc.
self.assertTrue(pwd.getpwnam(e.pw_name) in entriesbyname[e.pw_name]) self.assertIn(pwd.getpwnam(e.pw_name), entriesbyname[e.pw_name])
self.assertTrue(pwd.getpwuid(e.pw_uid) in entriesbyuid[e.pw_uid]) self.assertIn(pwd.getpwuid(e.pw_uid), entriesbyuid[e.pw_uid])
def test_errors(self): def test_errors(self):
self.assertRaises(TypeError, pwd.getpwuid) self.assertRaises(TypeError, pwd.getpwuid)

6
Lib/test/test_py3kwarn.py
View file

@ -350,9 +350,9 @@ def check_removal(self, module_name, optional=False):
try: try:
__import__(module_name, level=0) __import__(module_name, level=0)
except DeprecationWarning as exc: except DeprecationWarning as exc:
self.assertTrue(module_name in exc.args[0], self.assertIn(module_name, exc.args[0],
"%s warning didn't contain module name" "%s warning didn't contain module name"
% module_name) % module_name)
except ImportError: except ImportError:
if not optional: if not optional:
self.fail("Non-optional module {0} raised an " self.fail("Non-optional module {0} raised an "

6
Lib/test/test_pydoc.py
View file

@ -298,7 +298,7 @@ def test_module(self):
# Check that pydocfodder module can be described # Check that pydocfodder module can be described
from test import pydocfodder from test import pydocfodder
doc = pydoc.render_doc(pydocfodder) doc = pydoc.render_doc(pydocfodder)
self.assertTrue("pydocfodder" in doc) self.assertIn("pydocfodder", doc)
def test_classic_class(self): def test_classic_class(self):
class C: "Classic class" class C: "Classic class"
@ -306,7 +306,7 @@ class C: "Classic class"
self.assertEqual(pydoc.describe(C), 'class C') self.assertEqual(pydoc.describe(C), 'class C')
self.assertEqual(pydoc.describe(c), 'instance of C') self.assertEqual(pydoc.describe(c), 'instance of C')
expected = 'instance of C in module %s' % __name__ expected = 'instance of C in module %s' % __name__
self.assertTrue(expected in pydoc.render_doc(c)) self.assertIn(expected, pydoc.render_doc(c))
def test_class(self): def test_class(self):
class C(object): "New-style class" class C(object): "New-style class"
@ -315,7 +315,7 @@ class C(object): "New-style class"
self.assertEqual(pydoc.describe(C), 'class C') self.assertEqual(pydoc.describe(C), 'class C')
self.assertEqual(pydoc.describe(c), 'C') self.assertEqual(pydoc.describe(c), 'C')
expected = 'C in module %s object' % __name__ expected = 'C in module %s object' % __name__
self.assertTrue(expected in pydoc.render_doc(c)) self.assertIn(expected, pydoc.render_doc(c))
def test_main(): def test_main():

4
Lib/test/test_random.py
View file

@ -289,7 +289,7 @@ def test_randbelow_logic(self, _log=log, int=int):
n += n - 1 # check 1 below the next power of two n += n - 1 # check 1 below the next power of two
k = int(1.00001 + _log(n, 2)) k = int(1.00001 + _log(n, 2))
self.assertTrue(k in [numbits, numbits+1]) self.assertIn(k, [numbits, numbits+1])
self.assertTrue(2**k > n > 2**(k-2)) self.assertTrue(2**k > n > 2**(k-2))
n -= n >> 15 # check a little farther below the next power of two n -= n >> 15 # check a little farther below the next power of two
@ -445,7 +445,7 @@ def test_randbelow_logic(self, _log=log, int=int):
n += n - 1 # check 1 below the next power of two n += n - 1 # check 1 below the next power of two
k = int(1.00001 + _log(n, 2)) k = int(1.00001 + _log(n, 2))
self.assertTrue(k in [numbits, numbits+1]) self.assertIn(k, [numbits, numbits+1])
self.assertTrue(2**k > n > 2**(k-2)) self.assertTrue(2**k > n > 2**(k-2))
n -= n >> 15 # check a little farther below the next power of two n -= n >> 15 # check a little farther below the next power of two

20
Lib/test/test_runpy.py
View file

@ -165,14 +165,14 @@ def _check_module(self, depth):
try: try:
if verbose: print "Running from source:", mod_name if verbose: print "Running from source:", mod_name
d1 = run_module(mod_name) # Read from source d1 = run_module(mod_name) # Read from source
self.assertTrue("x" in d1) self.assertIn("x", d1)
self.assertTrue(d1["x"] == 1) self.assertTrue(d1["x"] == 1)
del d1 # Ensure __loader__ entry doesn't keep file open del d1 # Ensure __loader__ entry doesn't keep file open
__import__(mod_name) __import__(mod_name)
os.remove(mod_fname) os.remove(mod_fname)
if verbose: print "Running from compiled:", mod_name if verbose: print "Running from compiled:", mod_name
d2 = run_module(mod_name) # Read from bytecode d2 = run_module(mod_name) # Read from bytecode
self.assertTrue("x" in d2) self.assertIn("x", d2)
self.assertTrue(d2["x"] == 1) self.assertTrue(d2["x"] == 1)
del d2 # Ensure __loader__ entry doesn't keep file open del d2 # Ensure __loader__ entry doesn't keep file open
finally: finally:
@ -187,14 +187,14 @@ def _check_package(self, depth):
try: try:
if verbose: print "Running from source:", pkg_name if verbose: print "Running from source:", pkg_name
d1 = run_module(pkg_name) # Read from source d1 = run_module(pkg_name) # Read from source
self.assertTrue("x" in d1) self.assertIn("x", d1)
self.assertTrue(d1["x"] == 1) self.assertTrue(d1["x"] == 1)
del d1 # Ensure __loader__ entry doesn't keep file open del d1 # Ensure __loader__ entry doesn't keep file open
__import__(mod_name) __import__(mod_name)
os.remove(mod_fname) os.remove(mod_fname)
if verbose: print "Running from compiled:", pkg_name if verbose: print "Running from compiled:", pkg_name
d2 = run_module(pkg_name) # Read from bytecode d2 = run_module(pkg_name) # Read from bytecode
self.assertTrue("x" in d2) self.assertIn("x", d2)
self.assertTrue(d2["x"] == 1) self.assertTrue(d2["x"] == 1)
del d2 # Ensure __loader__ entry doesn't keep file open del d2 # Ensure __loader__ entry doesn't keep file open
finally: finally:
@ -239,19 +239,19 @@ def _check_relative_imports(self, depth, run_name=None):
pkg_name = mod_name.rpartition('.')[0] pkg_name = mod_name.rpartition('.')[0]
if verbose: print "Running from source:", mod_name if verbose: print "Running from source:", mod_name
d1 = run_module(mod_name, run_name=run_name) # Read from source d1 = run_module(mod_name, run_name=run_name) # Read from source
self.assertTrue("__package__" in d1) self.assertIn("__package__", d1)
self.assertTrue(d1["__package__"] == pkg_name) self.assertTrue(d1["__package__"] == pkg_name)
self.assertTrue("sibling" in d1) self.assertIn("sibling", d1)
self.assertTrue("nephew" in d1) self.assertIn("nephew", d1)
del d1 # Ensure __loader__ entry doesn't keep file open del d1 # Ensure __loader__ entry doesn't keep file open
__import__(mod_name) __import__(mod_name)
os.remove(mod_fname) os.remove(mod_fname)
if verbose: print "Running from compiled:", mod_name if verbose: print "Running from compiled:", mod_name
d2 = run_module(mod_name, run_name=run_name) # Read from bytecode d2 = run_module(mod_name, run_name=run_name) # Read from bytecode
self.assertTrue("__package__" in d2) self.assertIn("__package__", d2)
self.assertTrue(d2["__package__"] == pkg_name) self.assertTrue(d2["__package__"] == pkg_name)
self.assertTrue("sibling" in d2) self.assertIn("sibling", d2)
self.assertTrue("nephew" in d2) self.assertIn("nephew", d2)
del d2 # Ensure __loader__ entry doesn't keep file open del d2 # Ensure __loader__ entry doesn't keep file open
finally: finally:
self._del_pkg(pkg_dir, depth, mod_name) self._del_pkg(pkg_dir, depth, mod_name)

4
Lib/test/test_scope.py
View file

@ -505,8 +505,8 @@ def m(self):
return C return C
varnames = f(1).z varnames = f(1).z
self.assertTrue("x" not in varnames) self.assertNotIn("x", varnames)
self.assertTrue("y" in varnames) self.assertIn("y", varnames)
def testLocalsClass_WithTrace(self): def testLocalsClass_WithTrace(self):
# Issue23728: after the trace function returns, the locals() # Issue23728: after the trace function returns, the locals()

62
Lib/test/test_set.py
View file

@ -64,7 +64,7 @@ def test_contains(self):
self.assertEqual(c in self.s, c in self.d) self.assertEqual(c in self.s, c in self.d)
self.assertRaises(TypeError, self.s.__contains__, [[]]) self.assertRaises(TypeError, self.s.__contains__, [[]])
s = self.thetype([frozenset(self.letters)]) s = self.thetype([frozenset(self.letters)])
self.assertTrue(self.thetype(self.letters) in s) self.assertIn(self.thetype(self.letters), s)
def test_union(self): def test_union(self):
u = self.s.union(self.otherword) u = self.s.union(self.otherword)
@ -271,7 +271,7 @@ def __hash__(self):
s=H() s=H()
f=set() f=set()
f.add(s) f.add(s)
self.assertTrue(s in f) self.assertIn(s, f)
f.remove(s) f.remove(s)
f.add(s) f.add(s)
f.discard(s) f.discard(s)
@ -371,7 +371,7 @@ def test_copy(self):
def test_add(self): def test_add(self):
self.s.add('Q') self.s.add('Q')
self.assertTrue('Q' in self.s) self.assertIn('Q', self.s)
dup = self.s.copy() dup = self.s.copy()
self.s.add('Q') self.s.add('Q')
self.assertEqual(self.s, dup) self.assertEqual(self.s, dup)
@ -379,13 +379,13 @@ def test_add(self):
def test_remove(self): def test_remove(self):
self.s.remove('a') self.s.remove('a')
self.assertTrue('a' not in self.s) self.assertNotIn('a', self.s)
self.assertRaises(KeyError, self.s.remove, 'Q') self.assertRaises(KeyError, self.s.remove, 'Q')
self.assertRaises(TypeError, self.s.remove, []) self.assertRaises(TypeError, self.s.remove, [])
s = self.thetype([frozenset(self.word)]) s = self.thetype([frozenset(self.word)])
self.assertTrue(self.thetype(self.word) in s) self.assertIn(self.thetype(self.word), s)
s.remove(self.thetype(self.word)) s.remove(self.thetype(self.word))
self.assertTrue(self.thetype(self.word) not in s) self.assertNotIn(self.thetype(self.word), s)
self.assertRaises(KeyError, self.s.remove, self.thetype(self.word)) self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
def test_remove_keyerror_unpacking(self): def test_remove_keyerror_unpacking(self):
@ -412,26 +412,26 @@ def test_remove_keyerror_set(self):
def test_discard(self): def test_discard(self):
self.s.discard('a') self.s.discard('a')
self.assertTrue('a' not in self.s) self.assertNotIn('a', self.s)
self.s.discard('Q') self.s.discard('Q')
self.assertRaises(TypeError, self.s.discard, []) self.assertRaises(TypeError, self.s.discard, [])
s = self.thetype([frozenset(self.word)]) s = self.thetype([frozenset(self.word)])
self.assertTrue(self.thetype(self.word) in s) self.assertIn(self.thetype(self.word), s)
s.discard(self.thetype(self.word)) s.discard(self.thetype(self.word))
self.assertTrue(self.thetype(self.word) not in s) self.assertNotIn(self.thetype(self.word), s)
s.discard(self.thetype(self.word)) s.discard(self.thetype(self.word))
def test_pop(self): def test_pop(self):
for i in xrange(len(self.s)): for i in xrange(len(self.s)):
elem = self.s.pop() elem = self.s.pop()
self.assertTrue(elem not in self.s) self.assertNotIn(elem, self.s)
self.assertRaises(KeyError, self.s.pop) self.assertRaises(KeyError, self.s.pop)
def test_update(self): def test_update(self):
retval = self.s.update(self.otherword) retval = self.s.update(self.otherword)
self.assertEqual(retval, None) self.assertEqual(retval, None)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
self.assertTrue(c in self.s) self.assertIn(c, self.s)
self.assertRaises(PassThru, self.s.update, check_pass_thru()) self.assertRaises(PassThru, self.s.update, check_pass_thru())
self.assertRaises(TypeError, self.s.update, [[]]) self.assertRaises(TypeError, self.s.update, [[]])
for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')): for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):
@ -449,16 +449,16 @@ def test_update(self):
def test_ior(self): def test_ior(self):
self.s |= set(self.otherword) self.s |= set(self.otherword)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
self.assertTrue(c in self.s) self.assertIn(c, self.s)
def test_intersection_update(self): def test_intersection_update(self):
retval = self.s.intersection_update(self.otherword) retval = self.s.intersection_update(self.otherword)
self.assertEqual(retval, None) self.assertEqual(retval, None)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if c in self.otherword and c in self.word: if c in self.otherword and c in self.word:
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru()) self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
self.assertRaises(TypeError, self.s.intersection_update, [[]]) self.assertRaises(TypeError, self.s.intersection_update, [[]])
for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')): for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):
@ -476,18 +476,18 @@ def test_iand(self):
self.s &= set(self.otherword) self.s &= set(self.otherword)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if c in self.otherword and c in self.word: if c in self.otherword and c in self.word:
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
def test_difference_update(self): def test_difference_update(self):
retval = self.s.difference_update(self.otherword) retval = self.s.difference_update(self.otherword)
self.assertEqual(retval, None) self.assertEqual(retval, None)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if c in self.word and c not in self.otherword: if c in self.word and c not in self.otherword:
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
self.assertRaises(PassThru, self.s.difference_update, check_pass_thru()) self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
self.assertRaises(TypeError, self.s.difference_update, [[]]) self.assertRaises(TypeError, self.s.difference_update, [[]])
self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]]) self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
@ -513,18 +513,18 @@ def test_isub(self):
self.s -= set(self.otherword) self.s -= set(self.otherword)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if c in self.word and c not in self.otherword: if c in self.word and c not in self.otherword:
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
def test_symmetric_difference_update(self): def test_symmetric_difference_update(self):
retval = self.s.symmetric_difference_update(self.otherword) retval = self.s.symmetric_difference_update(self.otherword)
self.assertEqual(retval, None) self.assertEqual(retval, None)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if (c in self.word) ^ (c in self.otherword): if (c in self.word) ^ (c in self.otherword):
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru()) self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]]) self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')): for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):
@ -537,9 +537,9 @@ def test_ixor(self):
self.s ^= set(self.otherword) self.s ^= set(self.otherword)
for c in (self.word + self.otherword): for c in (self.word + self.otherword):
if (c in self.word) ^ (c in self.otherword): if (c in self.word) ^ (c in self.otherword):
self.assertTrue(c in self.s) self.assertIn(c, self.s)
else: else:
self.assertTrue(c not in self.s) self.assertNotIn(c, self.s)
def test_inplace_on_self(self): def test_inplace_on_self(self):
t = self.s.copy() t = self.s.copy()
@ -767,7 +767,7 @@ def test_empty_difference_rev(self):
def test_iteration(self): def test_iteration(self):
for v in self.set: for v in self.set:
self.assertTrue(v in self.values) self.assertIn(v, self.values)
setiter = iter(self.set) setiter = iter(self.set)
# note: __length_hint__ is an internal undocumented API, # note: __length_hint__ is an internal undocumented API,
# don't rely on it in your own programs # don't rely on it in your own programs
@ -802,10 +802,10 @@ def setUp(self):
self.repr = "set([3])" self.repr = "set([3])"
def test_in(self): def test_in(self):
self.assertTrue(3 in self.set) self.assertIn(3, self.set)
def test_not_in(self): def test_not_in(self):
self.assertTrue(2 not in self.set) self.assertNotIn(2, self.set)
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
@ -819,10 +819,10 @@ def setUp(self):
self.repr = "set([(0, 'zero')])" self.repr = "set([(0, 'zero')])"
def test_in(self): def test_in(self):
self.assertTrue((0, "zero") in self.set) self.assertIn((0, "zero"), self.set)
def test_not_in(self): def test_not_in(self):
self.assertTrue(9 not in self.set) self.assertNotIn(9, self.set)
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
@ -1114,7 +1114,7 @@ def test_pop(self):
popped[self.set.pop()] = None popped[self.set.pop()] = None
self.assertEqual(len(popped), len(self.values)) self.assertEqual(len(popped), len(self.values))
for v in self.values: for v in self.values:
self.assertTrue(v in popped) self.assertIn(v, popped)
def test_update_empty_tuple(self): def test_update_empty_tuple(self):
self.set.update(()) self.set.update(())
@ -1688,7 +1688,7 @@ def test_cuboctahedron(self):
edge = vertex # Cuboctahedron vertices are edges in Cube edge = vertex # Cuboctahedron vertices are edges in Cube
self.assertEqual(len(edge), 2) # Two cube vertices define an edge self.assertEqual(len(edge), 2) # Two cube vertices define an edge
for cubevert in edge: for cubevert in edge:
self.assertTrue(cubevert in g) self.assertIn(cubevert, g)
#============================================================================== #==============================================================================

4
Lib/test/test_sets.py
View file

@ -76,7 +76,7 @@ def test_empty_difference_rev(self):
def test_iteration(self): def test_iteration(self):
for v in self.set: for v in self.set:
self.assertTrue(v in self.values) self.assertIn(v, self.values)
def test_pickling(self): def test_pickling(self):
p = pickle.dumps(self.set) p = pickle.dumps(self.set)
@ -406,7 +406,7 @@ def test_pop(self):
popped[self.set.pop()] = None popped[self.set.pop()] = None
self.assertEqual(len(popped), len(self.values)) self.assertEqual(len(popped), len(self.values))
for v in self.values: for v in self.values:
self.assertTrue(v in popped) self.assertIn(v, popped)
def test_update_empty_tuple(self): def test_update_empty_tuple(self):
self.set.union_update(()) self.set.union_update(())

12
Lib/test/test_site.py
View file

@ -68,14 +68,14 @@ def test_init_pathinfo(self):
dir_set = site._init_pathinfo() dir_set = site._init_pathinfo()
for entry in [site.makepath(path)[1] for path in sys.path for entry in [site.makepath(path)[1] for path in sys.path
if path and os.path.isdir(path)]: if path and os.path.isdir(path)]:
self.assertTrue(entry in dir_set, self.assertIn(entry, dir_set,
"%s from sys.path not found in set returned " "%s from sys.path not found in set returned "
"by _init_pathinfo(): %s" % (entry, dir_set)) "by _init_pathinfo(): %s" % (entry, dir_set))
def pth_file_tests(self, pth_file): def pth_file_tests(self, pth_file):
"""Contain common code for testing results of reading a .pth file""" """Contain common code for testing results of reading a .pth file"""
self.assertTrue(pth_file.imported in sys.modules, self.assertIn(pth_file.imported, sys.modules,
"%s not in sys.modules" % pth_file.imported) "%s not in sys.modules" % pth_file.imported)
self.assertIn(site.makepath(pth_file.good_dir_path)[0], sys.path) self.assertIn(site.makepath(pth_file.good_dir_path)[0], sys.path)
self.assertFalse(os.path.exists(pth_file.bad_dir_path)) self.assertFalse(os.path.exists(pth_file.bad_dir_path))
@ -279,7 +279,7 @@ def test_no_duplicate_paths(self):
site.removeduppaths() site.removeduppaths()
seen_paths = set() seen_paths = set()
for path in sys.path: for path in sys.path:
self.assertTrue(path not in seen_paths) self.assertNotIn(path, seen_paths)
seen_paths.add(path) seen_paths.add(path)
def test_add_build_dir(self): def test_add_build_dir(self):

2
Lib/test/test_socket.py
View file

@ -491,7 +491,7 @@ def testSockName(self):
# it reasonable to get the host's addr in addition to 0.0.0.0. # it reasonable to get the host's addr in addition to 0.0.0.0.
# At least for eCos. This is required for the S/390 to pass. # At least for eCos. This is required for the S/390 to pass.
my_ip_addr = socket.gethostbyname(socket.gethostname()) my_ip_addr = socket.gethostbyname(socket.gethostname())
self.assertTrue(name[0] in ("0.0.0.0", my_ip_addr), '%s invalid' % name[0]) self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
self.assertEqual(name[1], port) self.assertEqual(name[1], port)
def testGetSockOpt(self): def testGetSockOpt(self):

16
Lib/test/test_strptime.py
View file

@ -36,8 +36,8 @@ def compare_against_time(self, testing, directive, tuple_position,
""" """
strftime_output = time.strftime(directive, self.time_tuple).lower() strftime_output = time.strftime(directive, self.time_tuple).lower()
comparison = testing[self.time_tuple[tuple_position]] comparison = testing[self.time_tuple[tuple_position]]
self.assertTrue(strftime_output in testing, "%s: not found in tuple" % self.assertIn(strftime_output, testing,
error_msg) "%s: not found in tuple" % error_msg)
self.assertTrue(comparison == strftime_output, self.assertTrue(comparison == strftime_output,
"%s: position within tuple incorrect; %s != %s" % "%s: position within tuple incorrect; %s != %s" %
(error_msg, comparison, strftime_output)) (error_msg, comparison, strftime_output))
@ -61,8 +61,8 @@ def test_month(self):
def test_am_pm(self): def test_am_pm(self):
# Make sure AM/PM representation done properly # Make sure AM/PM representation done properly
strftime_output = time.strftime("%p", self.time_tuple).lower() strftime_output = time.strftime("%p", self.time_tuple).lower()
self.assertTrue(strftime_output in self.LT_ins.am_pm, self.assertIn(strftime_output, self.LT_ins.am_pm,
"AM/PM representation not in tuple") "AM/PM representation not in tuple")
if self.time_tuple[3] < 12: position = 0 if self.time_tuple[3] < 12: position = 0
else: position = 1 else: position = 1
self.assertTrue(strftime_output == self.LT_ins.am_pm[position], self.assertTrue(strftime_output == self.LT_ins.am_pm[position],
@ -72,7 +72,7 @@ def test_timezone(self):
# Make sure timezone is correct # Make sure timezone is correct
timezone = time.strftime("%Z", self.time_tuple).lower() timezone = time.strftime("%Z", self.time_tuple).lower()
if timezone: if timezone:
self.assertTrue(timezone in self.LT_ins.timezone[0] or \ self.assertTrue(timezone in self.LT_ins.timezone[0] or
timezone in self.LT_ins.timezone[1], timezone in self.LT_ins.timezone[1],
"timezone %s not found in %s" % "timezone %s not found in %s" %
(timezone, self.LT_ins.timezone)) (timezone, self.LT_ins.timezone))
@ -133,9 +133,9 @@ def test_pattern_escaping(self):
# Make sure any characters in the format string that might be taken as # Make sure any characters in the format string that might be taken as
# regex syntax is escaped. # regex syntax is escaped.
pattern_string = self.time_re.pattern("\d+") pattern_string = self.time_re.pattern("\d+")
self.assertTrue(r"\\d\+" in pattern_string, self.assertIn(r"\\d\+", pattern_string,
"%s does not have re characters escaped properly" % "%s does not have re characters escaped properly" %
pattern_string) pattern_string)
def test_compile(self): def test_compile(self):
# Check that compiled regex is correct # Check that compiled regex is correct

4
Lib/test/test_structseq.py
View file

@ -50,8 +50,8 @@ def test_repeat(self):
def test_contains(self): def test_contains(self):
t1 = time.gmtime() t1 = time.gmtime()
for item in t1: for item in t1:
self.assertTrue(item in t1) self.assertIn(item, t1)
self.assertTrue(-42 not in t1) self.assertNotIn(-42, t1)
def test_hash(self): def test_hash(self):
t1 = time.gmtime() t1 = time.gmtime()

6
Lib/test/test_subprocess.py
View file

@ -76,7 +76,7 @@ def test_check_output(self):
# check_output() function with zero return code # check_output() function with zero return code
output = subprocess.check_output( output = subprocess.check_output(
[sys.executable, "-c", "print 'BDFL'"]) [sys.executable, "-c", "print 'BDFL'"])
self.assertTrue('BDFL' in output) self.assertIn('BDFL', output)
def test_check_output_nonzero(self): def test_check_output_nonzero(self):
# check_call() function with non-zero return code # check_call() function with non-zero return code
@ -93,7 +93,7 @@ def test_check_output_stderr(self):
output = subprocess.check_output( output = subprocess.check_output(
[sys.executable, "-c", "import sys; sys.stderr.write('BDFL')"], [sys.executable, "-c", "import sys; sys.stderr.write('BDFL')"],
stderr=subprocess.STDOUT) stderr=subprocess.STDOUT)
self.assertTrue('BDFL' in output) self.assertIn('BDFL', output)
def test_check_output_stdout_arg(self): def test_check_output_stdout_arg(self):
# check_output() function stderr redirected to stdout # check_output() function stderr redirected to stdout
@ -102,7 +102,7 @@ def test_check_output_stdout_arg(self):
[sys.executable, "-c", "print 'will not be run'"], [sys.executable, "-c", "print 'will not be run'"],
stdout=sys.stdout) stdout=sys.stdout)
except ValueError, e: except ValueError, e:
self.assertTrue('stdout' in e.args[0]) self.assertIn('stdout', e.args[0])
else: else:
self.fail("Expected ValueError when stdout arg supplied.") self.fail("Expected ValueError when stdout arg supplied.")

17
Lib/test/test_sys.py
View file

@ -293,8 +293,8 @@ def g456():
d = sys._current_frames() d = sys._current_frames()
main_id = thread.get_ident() main_id = thread.get_ident()
self.assertTrue(main_id in d) self.assertIn(main_id, d)
self.assertTrue(thread_id in d) self.assertIn(thread_id, d)
# Verify that the captured main-thread frame is _this_ frame. # Verify that the captured main-thread frame is _this_ frame.
frame = d.pop(main_id) frame = d.pop(main_id)
@ -316,7 +316,7 @@ def g456():
# And the next record must be for g456(). # And the next record must be for g456().
filename, lineno, funcname, sourceline = stack[i+1] filename, lineno, funcname, sourceline = stack[i+1]
self.assertEqual(funcname, "g456") self.assertEqual(funcname, "g456")
self.assertTrue(sourceline in ["leave_g.wait()", "entered_g.set()"]) self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
# Reap the spawned thread. # Reap the spawned thread.
leave_g.set() leave_g.set()
@ -328,13 +328,13 @@ def current_frames_without_threads(self):
# "thread id" 0. # "thread id" 0.
d = sys._current_frames() d = sys._current_frames()
self.assertEqual(len(d), 1) self.assertEqual(len(d), 1)
self.assertTrue(0 in d) self.assertIn(0, d)
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.assertTrue(isinstance(sys.api_version, int))
self.assertTrue(isinstance(sys.argv, list)) self.assertTrue(isinstance(sys.argv, list))
self.assertTrue(sys.byteorder in ("little", "big")) self.assertIn(sys.byteorder, ("little", "big"))
self.assertTrue(isinstance(sys.builtin_module_names, tuple)) self.assertTrue(isinstance(sys.builtin_module_names, tuple))
self.assertTrue(isinstance(sys.copyright, basestring)) self.assertTrue(isinstance(sys.copyright, basestring))
self.assertTrue(isinstance(sys.exec_prefix, basestring)) self.assertTrue(isinstance(sys.exec_prefix, basestring))
@ -359,13 +359,12 @@ def test_attributes(self):
self.assertTrue(isinstance(vi[0], int)) self.assertTrue(isinstance(vi[0], int))
self.assertTrue(isinstance(vi[1], int)) self.assertTrue(isinstance(vi[1], int))
self.assertTrue(isinstance(vi[2], int)) self.assertTrue(isinstance(vi[2], int))
self.assertTrue(vi[3] in ("alpha", "beta", "candidate", "final")) self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertTrue(isinstance(vi[4], int)) self.assertTrue(isinstance(vi[4], int))
self.assertTrue(isinstance(vi.major, int)) self.assertTrue(isinstance(vi.major, int))
self.assertTrue(isinstance(vi.minor, int)) self.assertTrue(isinstance(vi.minor, int))
self.assertTrue(isinstance(vi.micro, int)) self.assertTrue(isinstance(vi.micro, int))
self.assertTrue(vi.releaselevel in self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
("alpha", "beta", "candidate", "final"))
self.assertTrue(isinstance(vi.serial, int)) self.assertTrue(isinstance(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)
@ -374,7 +373,7 @@ def test_attributes(self):
self.assertEqual(vi[4], vi.serial) self.assertEqual(vi[4], vi.serial)
self.assertTrue(vi > (1,0,0)) self.assertTrue(vi > (1,0,0))
self.assertIsInstance(sys.float_repr_style, str) self.assertIsInstance(sys.float_repr_style, str)
self.assertTrue(sys.float_repr_style in ('short', 'legacy')) self.assertIn(sys.float_repr_style, ('short', 'legacy'))
def test_43581(self): def test_43581(self):
# Can't use sys.stdout, as this is a cStringIO object when # Can't use sys.stdout, as this is a cStringIO object when

2
Lib/test/test_tarfile.py
View file

@ -486,7 +486,7 @@ def test_find_umlauts(self):
def test_find_ustar_longname(self): def test_find_ustar_longname(self):
name = "ustar/" + "12345/" * 39 + "1234567/longname" name = "ustar/" + "12345/" * 39 + "1234567/longname"
self.assertTrue(name in self.tar.getnames()) self.assertIn(name, self.tar.getnames())
def test_find_regtype_oldv7(self): def test_find_regtype_oldv7(self):
tarinfo = self.tar.getmember("misc/regtype-old-v7") tarinfo = self.tar.getmember("misc/regtype-old-v7")

2
Lib/test/test_telnetlib.py
View file

@ -321,7 +321,7 @@ def _test_command(self, data):
txt = telnet.read_all() txt = telnet.read_all()
cmd = nego.seen cmd = nego.seen
self.assertTrue(len(cmd) > 0) # we expect at least one command self.assertTrue(len(cmd) > 0) # we expect at least one command
self.assertTrue(cmd[0] in self.cmds) self.assertIn(cmd[0], self.cmds)
self.assertEqual(cmd[1], tl.NOOPT) self.assertEqual(cmd[1], tl.NOOPT)
self.assertEqual(len(''.join(data[:-1])), len(txt + cmd)) self.assertEqual(len(''.join(data[:-1])), len(txt + cmd))
nego.sb_getter = None # break the nego => telnet cycle nego.sb_getter = None # break the nego => telnet cycle

6
Lib/test/test_tempfile.py
View file

@ -113,7 +113,7 @@ def test_many(self):
for i in xrange(TEST_FILES): for i in xrange(TEST_FILES):
s = r.next() s = r.next()
self.nameCheck(s, '', '', '') self.nameCheck(s, '', '', '')
self.assertFalse(s in dict) self.assertNotIn(s, dict)
dict[s] = 1 dict[s] = 1
def test_supports_iter(self): def test_supports_iter(self):
@ -160,14 +160,14 @@ def test_wanted_dirs(self):
for envname in 'TMPDIR', 'TEMP', 'TMP': for envname in 'TMPDIR', 'TEMP', 'TMP':
dirname = os.getenv(envname) dirname = os.getenv(envname)
if not dirname: raise ValueError if not dirname: raise ValueError
self.assertTrue(dirname in cand) self.assertIn(dirname, cand)
try: try:
dirname = os.getcwd() dirname = os.getcwd()
except (AttributeError, os.error): except (AttributeError, os.error):
dirname = os.curdir dirname = os.curdir
self.assertTrue(dirname in cand) self.assertIn(dirname, cand)
# Not practical to try to verify the presence of OS-specific # Not practical to try to verify the presence of OS-specific
# paths in this list. # paths in this list.

4
Lib/test/test_threading.py
View file

@ -153,7 +153,7 @@ def f(mutex):
tid = thread.start_new_thread(f, (mutex,)) tid = thread.start_new_thread(f, (mutex,))
# Wait for the thread to finish. # Wait for the thread to finish.
mutex.acquire() mutex.acquire()
self.assertTrue(tid in threading._active) self.assertIn(tid, threading._active)
self.assertTrue(isinstance(threading._active[tid], self.assertTrue(isinstance(threading._active[tid],
threading._DummyThread)) threading._DummyThread))
del threading._active[tid] del threading._active[tid]
@ -356,7 +356,7 @@ def test_enumerate_after_join(self):
t.start() t.start()
t.join() t.join()
l = enum() l = enum()
self.assertFalse(t in l, self.assertNotIn(t, l,
"#1703448 triggered after %d trials: %s" % (i, l)) "#1703448 triggered after %d trials: %s" % (i, l))
finally: finally:
sys.setcheckinterval(old_interval) sys.setcheckinterval(old_interval)

2
Lib/test/test_threading_local.py
View file

@ -40,7 +40,7 @@ def _local_refs(self, n):
local.someothervar = None local.someothervar = None
gc.collect() gc.collect()
deadlist = [weak for weak in weaklist if weak() is None] deadlist = [weak for weak in weaklist if weak() is None]
self.assertTrue(len(deadlist) in (n-1, n), (n, len(deadlist))) self.assertIn(len(deadlist), (n-1, n), (n, len(deadlist)))
def test_derived(self): def test_derived(self):
# Issue 3088: if there is a threads switch inside the __init__ # Issue 3088: if there is a threads switch inside the __init__

6
Lib/test/test_traceback.py
View file

@ -39,12 +39,12 @@ def test_caret(self):
SyntaxError) SyntaxError)
self.assertTrue(len(err) == 4) self.assertTrue(len(err) == 4)
self.assertTrue(err[1].strip() == "return x!") self.assertTrue(err[1].strip() == "return x!")
self.assertTrue("^" in err[2]) # third line has caret self.assertIn("^", err[2]) # third line has caret
self.assertTrue(err[1].find("!") == err[2].find("^")) # in the right place self.assertTrue(err[1].find("!") == err[2].find("^")) # in the right place
err = self.get_exception_format(self.syntax_error_with_caret_2, err = self.get_exception_format(self.syntax_error_with_caret_2,
SyntaxError) SyntaxError)
self.assertTrue("^" in err[2]) # third line has caret self.assertIn("^", err[2]) # third line has caret
self.assertTrue(err[2].count('\n') == 1) # and no additional newline self.assertTrue(err[2].count('\n') == 1) # and no additional newline
self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place
@ -62,7 +62,7 @@ def test_bad_indentation(self):
IndentationError) IndentationError)
self.assertTrue(len(err) == 4) self.assertTrue(len(err) == 4)
self.assertTrue(err[1].strip() == "print 2") self.assertTrue(err[1].strip() == "print 2")
self.assertTrue("^" in err[2]) self.assertIn("^", err[2])
self.assertTrue(err[1].find("2") == err[2].find("^")) self.assertTrue(err[1].find("2") == err[2].find("^"))
def test_bug737473(self): def test_bug737473(self):

4
Lib/test/test_types.py
View file

@ -612,13 +612,13 @@ def test(f, format_spec, result):
result = f.__format__(fmt) result = f.__format__(fmt)
self.assertEqual(len(result), 98) self.assertEqual(len(result), 98)
self.assertEqual(result[-7], '.') self.assertEqual(result[-7], '.')
self.assertTrue(result[:12] in ('112340000000', '112339999999')) self.assertIn(result[:12], ('112340000000', '112339999999'))
f = 1.1234e200 f = 1.1234e200
for fmt in 'f', 'F': for fmt in 'f', 'F':
result = f.__format__(fmt) result = f.__format__(fmt)
self.assertEqual(len(result), 208) self.assertEqual(len(result), 208)
self.assertEqual(result[-7], '.') self.assertEqual(result[-7], '.')
self.assertTrue(result[:12] in ('112340000000', '112339999999')) self.assertIn(result[:12], ('112340000000', '112339999999'))
test( 1.0, 'e', '1.000000e+00') test( 1.0, 'e', '1.000000e+00')

102
Lib/test/test_unicode.py
View file

@ -316,30 +316,30 @@ def test_isnumeric(self):
def test_contains(self): def test_contains(self):
# Testing Unicode contains method # Testing Unicode contains method
self.assertTrue('a' in u'abdb') self.assertIn('a', u'abdb')
self.assertTrue('a' in u'bdab') self.assertIn('a', u'bdab')
self.assertTrue('a' in u'bdaba') self.assertIn('a', u'bdaba')
self.assertTrue('a' in u'bdba') self.assertIn('a', u'bdba')
self.assertTrue('a' in u'bdba') self.assertIn('a', u'bdba')
self.assertTrue(u'a' in u'bdba') self.assertIn(u'a', u'bdba')
self.assertTrue(u'a' not in u'bdb') self.assertNotIn(u'a', u'bdb')
self.assertTrue(u'a' not in 'bdb') self.assertNotIn(u'a', 'bdb')
self.assertTrue(u'a' in 'bdba') self.assertIn(u'a', 'bdba')
self.assertTrue(u'a' in ('a',1,None)) self.assertIn(u'a', ('a',1,None))
self.assertTrue(u'a' in (1,None,'a')) self.assertIn(u'a', (1,None,'a'))
self.assertTrue(u'a' in (1,None,u'a')) self.assertIn(u'a', (1,None,u'a'))
self.assertTrue('a' in ('a',1,None)) self.assertIn('a', ('a',1,None))
self.assertTrue('a' in (1,None,'a')) self.assertIn('a', (1,None,'a'))
self.assertTrue('a' in (1,None,u'a')) self.assertIn('a', (1,None,u'a'))
self.assertTrue('a' not in ('x',1,u'y')) self.assertNotIn('a', ('x',1,u'y'))
self.assertTrue('a' not in ('x',1,None)) self.assertNotIn('a', ('x',1,None))
self.assertTrue(u'abcd' not in u'abcxxxx') self.assertNotIn(u'abcd', u'abcxxxx')
self.assertTrue(u'ab' in u'abcd') self.assertIn(u'ab', u'abcd')
self.assertTrue('ab' in u'abc') self.assertIn('ab', u'abc')
self.assertTrue(u'ab' in 'abc') self.assertIn(u'ab', 'abc')
self.assertTrue(u'ab' in (1,None,u'ab')) self.assertIn(u'ab', (1,None,u'ab'))
self.assertTrue(u'' in u'abc') self.assertIn(u'', u'abc')
self.assertTrue('' in u'abc') self.assertIn('', u'abc')
# If the following fails either # If the following fails either
# the contains operator does not propagate UnicodeErrors or # the contains operator does not propagate UnicodeErrors or
@ -347,33 +347,33 @@ def test_contains(self):
self.assertRaises(UnicodeDecodeError, 'g\xe2teau'.__contains__, u'\xe2') self.assertRaises(UnicodeDecodeError, 'g\xe2teau'.__contains__, u'\xe2')
self.assertRaises(UnicodeDecodeError, u'g\xe2teau'.__contains__, '\xe2') self.assertRaises(UnicodeDecodeError, u'g\xe2teau'.__contains__, '\xe2')
self.assertTrue(u'' in '') self.assertIn(u'', '')
self.assertTrue('' in u'') self.assertIn('', u'')
self.assertTrue(u'' in u'') self.assertIn(u'', u'')
self.assertTrue(u'' in 'abc') self.assertIn(u'', 'abc')
self.assertTrue('' in u'abc') self.assertIn('', u'abc')
self.assertTrue(u'' in u'abc') self.assertIn(u'', u'abc')
self.assertTrue(u'\0' not in 'abc') self.assertNotIn(u'\0', 'abc')
self.assertTrue('\0' not in u'abc') self.assertNotIn('\0', u'abc')
self.assertTrue(u'\0' not in u'abc') self.assertNotIn(u'\0', u'abc')
self.assertTrue(u'\0' in '\0abc') self.assertIn(u'\0', '\0abc')
self.assertTrue('\0' in u'\0abc') self.assertIn('\0', u'\0abc')
self.assertTrue(u'\0' in u'\0abc') self.assertIn(u'\0', u'\0abc')
self.assertTrue(u'\0' in 'abc\0') self.assertIn(u'\0', 'abc\0')
self.assertTrue('\0' in u'abc\0') self.assertIn('\0', u'abc\0')
self.assertTrue(u'\0' in u'abc\0') self.assertIn(u'\0', u'abc\0')
self.assertTrue(u'a' in '\0abc') self.assertIn(u'a', '\0abc')
self.assertTrue('a' in u'\0abc') self.assertIn('a', u'\0abc')
self.assertTrue(u'a' in u'\0abc') self.assertIn(u'a', u'\0abc')
self.assertTrue(u'asdf' in 'asdf') self.assertIn(u'asdf', 'asdf')
self.assertTrue('asdf' in u'asdf') self.assertIn('asdf', u'asdf')
self.assertTrue(u'asdf' in u'asdf') self.assertIn(u'asdf', u'asdf')
self.assertTrue(u'asdf' not in 'asd') self.assertNotIn(u'asdf', 'asd')
self.assertTrue('asdf' not in u'asd') self.assertNotIn('asdf', u'asd')
self.assertTrue(u'asdf' not in u'asd') self.assertNotIn(u'asdf', u'asd')
self.assertTrue(u'asdf' not in '') self.assertNotIn(u'asdf', '')
self.assertTrue('asdf' not in u'') self.assertNotIn('asdf', u'')
self.assertTrue(u'asdf' not in u'') self.assertNotIn(u'asdf', u'')
self.assertRaises(TypeError, u"abc".__contains__) self.assertRaises(TypeError, u"abc".__contains__)
self.assertRaises(TypeError, u"abc".__contains__, object()) self.assertRaises(TypeError, u"abc".__contains__, object())

2
Lib/test/test_unicode_file.py
View file

@ -71,7 +71,7 @@ def _do_single(self, filename):
base = unicodedata.normalize("NFD", base) base = unicodedata.normalize("NFD", base)
file_list = [unicodedata.normalize("NFD", f) for f in file_list] file_list = [unicodedata.normalize("NFD", f) for f in file_list]
self.assertTrue(base in file_list) self.assertIn(base, file_list)
# Do as many "equivalancy' tests as we can - ie, check that although we # Do as many "equivalancy' tests as we can - ie, check that although we
# have different types for the filename, they refer to the same file. # have different types for the filename, they refer to the same file.

2
Lib/test/test_unicodedata.py
View file

@ -218,7 +218,7 @@ def test_failed_import_during_compiling(self):
self.assertEqual(popen.returncode, 1) self.assertEqual(popen.returncode, 1)
error = "SyntaxError: (unicode error) \N escapes not supported " \ error = "SyntaxError: (unicode error) \N escapes not supported " \
"(can't load unicodedata module)" "(can't load unicodedata module)"
self.assertTrue(error in popen.stderr.read()) self.assertIn(error, popen.stderr.read())
def test_decimal_numeric_consistent(self): def test_decimal_numeric_consistent(self):
# Test that decimal and numeric are consistent, # Test that decimal and numeric are consistent,

8
Lib/test/test_unittest.py
View file

@ -636,7 +636,7 @@ def test_loadTestsFromName__module_not_loaded(self):
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# audioop should now be loaded, thanks to loadTestsFromName() # audioop should now be loaded, thanks to loadTestsFromName()
self.assertTrue(module_name in sys.modules) self.assertIn(module_name, sys.modules)
finally: finally:
if module_name in sys.modules: if module_name in sys.modules:
del sys.modules[module_name] del sys.modules[module_name]
@ -1024,7 +1024,7 @@ def test_loadTestsFromNames__module_not_loaded(self):
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()
self.assertTrue(module_name in sys.modules) self.assertIn(module_name, sys.modules)
finally: finally:
if module_name in sys.modules: if module_name in sys.modules:
del sys.modules[module_name] del sys.modules[module_name]
@ -3056,7 +3056,7 @@ def _raise(e):
try: try:
self.assertRaises(KeyError, lambda: None) self.assertRaises(KeyError, lambda: None)
except self.failureException as e: except self.failureException as e:
self.assert_("KeyError not raised" in e, str(e)) self.assertIn("KeyError not raised", e)
else: else:
self.fail("assertRaises() didn't fail") self.fail("assertRaises() didn't fail")
try: try:
@ -3073,7 +3073,7 @@ def _raise(e):
with self.assertRaises(KeyError): with self.assertRaises(KeyError):
pass pass
except self.failureException as e: except self.failureException as e:
self.assert_("KeyError not raised" in e, str(e)) self.assertIn("KeyError not raised", e)
else: else:
self.fail("assertRaises() didn't fail") self.fail("assertRaises() didn't fail")
try: try:

5
Lib/test/test_urllib.py
View file

@ -487,7 +487,7 @@ def help_inputtype(self, given, test_type):
expect_somewhere = ["1st=1", "2nd=2", "3rd=3"] expect_somewhere = ["1st=1", "2nd=2", "3rd=3"]
result = urllib.urlencode(given) result = urllib.urlencode(given)
for expected in expect_somewhere: for expected in expect_somewhere:
self.assertTrue(expected in result, self.assertIn(expected, result,
"testing %s: %s not found in %s" % "testing %s: %s not found in %s" %
(test_type, expected, result)) (test_type, expected, result))
self.assertEqual(result.count('&'), 2, self.assertEqual(result.count('&'), 2,
@ -534,8 +534,7 @@ def test_doseq(self):
result = urllib.urlencode(given, True) result = urllib.urlencode(given, True)
for value in given["sequence"]: for value in given["sequence"]:
expect = "sequence=%s" % value expect = "sequence=%s" % value
self.assertTrue(expect in result, self.assertIn(expect, result)
"%s not found in %s" % (expect, result))
self.assertEqual(result.count('&'), 2, self.assertEqual(result.count('&'), 2,
"Expected 2 '&'s, got %s" % result.count('&')) "Expected 2 '&'s, got %s" % result.count('&'))

18
Lib/test/test_urllib2.py
View file

@ -779,8 +779,8 @@ def test_http(self):
r = MockResponse(200, "OK", {}, "") r = MockResponse(200, "OK", {}, "")
newreq = h.do_request_(req) newreq = h.do_request_(req)
if data is None: # GET if data is None: # GET
self.assertTrue("Content-length" not in req.unredirected_hdrs) self.assertNotIn("Content-length", req.unredirected_hdrs)
self.assertTrue("Content-type" not in req.unredirected_hdrs) self.assertNotIn("Content-type", req.unredirected_hdrs)
else: # POST else: # POST
self.assertEqual(req.unredirected_hdrs["Content-length"], "0") self.assertEqual(req.unredirected_hdrs["Content-length"], "0")
self.assertEqual(req.unredirected_hdrs["Content-type"], self.assertEqual(req.unredirected_hdrs["Content-type"],
@ -897,13 +897,13 @@ def test_redirect(self):
# now it's a GET, there should not be headers regarding content # now it's a GET, there should not be headers regarding content
# (possibly dragged from before being a POST) # (possibly dragged from before being a POST)
headers = [x.lower() for x in o.req.headers] headers = [x.lower() for x in o.req.headers]
self.assertTrue("content-length" not in headers) self.assertNotIn("content-length", headers)
self.assertTrue("content-type" not in headers) self.assertNotIn("content-type", headers)
self.assertEqual(o.req.headers["Nonsense"], self.assertEqual(o.req.headers["Nonsense"],
"viking=withhold") "viking=withhold")
self.assertTrue("Spam" not in o.req.headers) self.assertNotIn("Spam", o.req.headers)
self.assertTrue("Spam" not in o.req.unredirected_hdrs) self.assertNotIn("Spam", o.req.unredirected_hdrs)
# loop detection # loop detection
req = Request(from_url) req = Request(from_url)
@ -1017,10 +1017,10 @@ def test_proxy_https_proxy_authorization(self):
# Verify Proxy-Authorization gets tunneled to request. # Verify Proxy-Authorization gets tunneled to request.
# httpsconn req_headers do not have the Proxy-Authorization header but # httpsconn req_headers do not have the Proxy-Authorization header but
# the req will have. # the req will have.
self.assertFalse(("Proxy-Authorization","FooBar") in self.assertNotIn(("Proxy-Authorization","FooBar"),
https_handler.httpconn.req_headers) https_handler.httpconn.req_headers)
self.assertTrue(("User-Agent","Grail") in self.assertIn(("User-Agent","Grail"),
https_handler.httpconn.req_headers) https_handler.httpconn.req_headers)
self.assertIsNotNone(req._tunnel_host) self.assertIsNotNone(req._tunnel_host)
self.assertEqual(req.get_host(), "proxy.example.com:3128") self.assertEqual(req.get_host(), "proxy.example.com:3128")
self.assertEqual(req.get_header("Proxy-authorization"),"FooBar") self.assertEqual(req.get_header("Proxy-authorization"),"FooBar")

14
Lib/test/test_userdict.py
View file

@ -96,7 +96,7 @@ def display(self): print self
# Test has_key and "in". # Test has_key and "in".
for i in u2.keys(): for i in u2.keys():
self.assertTrue(u2.has_key(i)) self.assertTrue(u2.has_key(i))
self.assertTrue(i in u2) self.assertIn(i, u2)
self.assertEqual(u1.has_key(i), d1.has_key(i)) self.assertEqual(u1.has_key(i), d1.has_key(i))
self.assertEqual(i in u1, i in d1) self.assertEqual(i in u1, i in d1)
self.assertEqual(u0.has_key(i), d0.has_key(i)) self.assertEqual(u0.has_key(i), d0.has_key(i))
@ -161,8 +161,8 @@ def __missing__(self, key):
d = D({1: 2, 3: 4}) d = D({1: 2, 3: 4})
self.assertEqual(d[1], 2) self.assertEqual(d[1], 2)
self.assertEqual(d[3], 4) self.assertEqual(d[3], 4)
self.assertTrue(2 not in d) self.assertNotIn(2, d)
self.assertTrue(2 not in d.keys()) self.assertNotIn(2, d.keys())
self.assertEqual(d[2], 42) self.assertEqual(d[2], 42)
class E(UserDict.UserDict): class E(UserDict.UserDict):
def __missing__(self, key): def __missing__(self, key):
@ -273,8 +273,8 @@ def test_all(self):
self.assertTrue(not s.has_key(20)) self.assertTrue(not s.has_key(20))
# __contains__ # __contains__
self.assertTrue(10 in s) self.assertIn(10, s)
self.assertTrue(20 not in s) self.assertNotIn(20, s)
# __iter__ # __iter__
self.assertEqual([k for k in s], [10, 30]) self.assertEqual([k for k in s], [10, 30])
@ -309,7 +309,7 @@ def test_all(self):
# pop # pop
self.assertEqual(s.pop(10), 'ten') self.assertEqual(s.pop(10), 'ten')
self.assertTrue(10 not in s) self.assertNotIn(10, s)
s[10] = 'ten' s[10] = 'ten'
self.assertEqual(s.pop("x", 1), 1) self.assertEqual(s.pop("x", 1), 1)
s["x"] = 42 s["x"] = 42
@ -317,7 +317,7 @@ def test_all(self):
# popitem # popitem
k, v = s.popitem() k, v = s.popitem()
self.assertTrue(k not in s) self.assertNotIn(k, s)
s[k] = v s[k] = v
# clear # clear

2
Lib/test/test_warnings.py
View file

@ -472,7 +472,7 @@ def test_showwarning_missing(self):
with test_support.captured_output('stderr') as stream: with test_support.captured_output('stderr') as stream:
self.module.warn(text) self.module.warn(text)
result = stream.getvalue() result = stream.getvalue()
self.assertTrue(text in result) self.assertIn(text, result)
def test_showwarning_not_callable(self): def test_showwarning_not_callable(self):
with original_warnings.catch_warnings(module=self.module): with original_warnings.catch_warnings(module=self.module):

17
Lib/test/test_weakref.py
View file

@ -172,8 +172,7 @@ def test_basic_proxy(self):
p[:] = [2, 3] p[:] = [2, 3]
self.assertEqual(len(L), 2) self.assertEqual(len(L), 2)
self.assertEqual(len(p), 2) self.assertEqual(len(p), 2)
self.assertTrue(3 in p, self.assertIn(3, p, "proxy didn't support __contains__() properly")
"proxy didn't support __contains__() properly")
p[1] = 5 p[1] = 5
self.assertEqual(L[1], 5) self.assertEqual(L[1], 5)
self.assertEqual(p[1], 5) self.assertEqual(p[1], 5)
@ -196,7 +195,7 @@ def __str__(self):
def __unicode__(self): def __unicode__(self):
return u"unicode" return u"unicode"
instance = C() instance = C()
self.assertTrue("__unicode__" in dir(weakref.proxy(instance))) self.assertIn("__unicode__", dir(weakref.proxy(instance)))
self.assertEqual(unicode(weakref.proxy(instance)), u"unicode") self.assertEqual(unicode(weakref.proxy(instance)), u"unicode")
def test_proxy_index(self): def test_proxy_index(self):
@ -718,8 +717,8 @@ class MyRef(weakref.ref):
refs = weakref.getweakrefs(o) refs = weakref.getweakrefs(o)
self.assertEqual(len(refs), 3) self.assertEqual(len(refs), 3)
self.assertTrue(r2 is refs[0]) self.assertTrue(r2 is refs[0])
self.assertTrue(r1 in refs[1:]) self.assertIn(r1, refs[1:])
self.assertTrue(r3 in refs[1:]) self.assertIn(r3, refs[1:])
def test_subclass_refs_dont_conflate_callbacks(self): def test_subclass_refs_dont_conflate_callbacks(self):
class MyRef(weakref.ref): class MyRef(weakref.ref):
@ -729,8 +728,8 @@ class MyRef(weakref.ref):
r2 = MyRef(o, str) r2 = MyRef(o, str)
self.assertTrue(r1 is not r2) self.assertTrue(r1 is not r2)
refs = weakref.getweakrefs(o) refs = weakref.getweakrefs(o)
self.assertTrue(r1 in refs) self.assertIn(r1, refs)
self.assertTrue(r2 in refs) self.assertIn(r2, refs)
def test_subclass_refs_with_slots(self): def test_subclass_refs_with_slots(self):
class MyRef(weakref.ref): class MyRef(weakref.ref):
@ -868,7 +867,7 @@ def test_weak_keyed_iters(self):
for wr in refs: for wr in refs:
ob = wr() ob = wr()
self.assertTrue(dict.has_key(ob)) self.assertTrue(dict.has_key(ob))
self.assertTrue(ob in dict) self.assertIn(ob, dict)
self.assertEqual(ob.arg, dict[ob]) self.assertEqual(ob.arg, dict[ob])
objects2.remove(ob) objects2.remove(ob)
self.assertEqual(len(objects2), 0) self.assertEqual(len(objects2), 0)
@ -879,7 +878,7 @@ def test_weak_keyed_iters(self):
for wr in dict.iterkeyrefs(): for wr in dict.iterkeyrefs():
ob = wr() ob = wr()
self.assertTrue(dict.has_key(ob)) self.assertTrue(dict.has_key(ob))
self.assertTrue(ob in dict) self.assertIn(ob, dict)
self.assertEqual(ob.arg, dict[ob]) self.assertEqual(ob.arg, dict[ob])
objects2.remove(ob) objects2.remove(ob)
self.assertEqual(len(objects2), 0) self.assertEqual(len(objects2), 0)

4
Lib/test/test_winreg.py
View file

@ -112,8 +112,8 @@ def ReadTestData(self, root_key):
data = EnumValue(sub_key, index) data = EnumValue(sub_key, index)
except EnvironmentError: except EnvironmentError:
break break
self.assertEquals(data in test_data, True, self.assertIn(data, test_data,
"Didn't read back the correct test data") "Didn't read back the correct test data")
index = index + 1 index = index + 1
self.assertEquals(index, len(test_data), self.assertEquals(index, len(test_data),
"Didn't read the correct number of items") "Didn't read the correct number of items")

8
Lib/test/test_xmlrpc.py
View file

@ -941,7 +941,7 @@ def send_user_agent(self, conn):
conn.putheader("X-Test", "test_custom_user_agent") conn.putheader("X-Test", "test_custom_user_agent")
req = self.issue_request(TestTransport) req = self.issue_request(TestTransport)
self.assertTrue("X-Test: test_custom_user_agent\r\n" in req) self.assertIn("X-Test: test_custom_user_agent\r\n", req)
def test_send_host(self): def test_send_host(self):
class TestTransport(FakeTransport): class TestTransport(FakeTransport):
@ -951,7 +951,7 @@ def send_host(self, conn, host):
conn.putheader("X-Test", "test_send_host") conn.putheader("X-Test", "test_send_host")
req = self.issue_request(TestTransport) req = self.issue_request(TestTransport)
self.assertTrue("X-Test: test_send_host\r\n" in req) self.assertIn("X-Test: test_send_host\r\n", req)
def test_send_request(self): def test_send_request(self):
class TestTransport(FakeTransport): class TestTransport(FakeTransport):
@ -961,7 +961,7 @@ def send_request(self, conn, url, body):
conn.putheader("X-Test", "test_send_request") conn.putheader("X-Test", "test_send_request")
req = self.issue_request(TestTransport) req = self.issue_request(TestTransport)
self.assertTrue("X-Test: test_send_request\r\n" in req) self.assertIn("X-Test: test_send_request\r\n", req)
def test_send_content(self): def test_send_content(self):
class TestTransport(FakeTransport): class TestTransport(FakeTransport):
@ -971,7 +971,7 @@ def send_content(self, conn, body):
xmlrpclib.Transport.send_content(self, conn, body) xmlrpclib.Transport.send_content(self, conn, body)
req = self.issue_request(TestTransport) req = self.issue_request(TestTransport)
self.assertTrue("X-Test: test_send_content\r\n" in req) self.assertIn("X-Test: test_send_content\r\n", req)
@test_support.reap_threads @test_support.reap_threads
def test_main(): def test_main():

12
Lib/test/test_xrange.py
View file

@ -63,18 +63,18 @@ def test_xrange(self):
self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2]) self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2])
seq = list(xrange(a, b, c)) seq = list(xrange(a, b, c))
self.assertTrue(a in seq) self.assertIn(a, seq)
self.assertTrue(b not in seq) self.assertNotIn(b, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = list(xrange(b, a, -c)) seq = list(xrange(b, a, -c))
self.assertTrue(b in seq) self.assertIn(b, seq)
self.assertTrue(a not in seq) self.assertNotIn(a, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = list(xrange(-a, -b, -c)) seq = list(xrange(-a, -b, -c))
self.assertTrue(-a in seq) self.assertIn(-a, seq)
self.assertTrue(-b not in seq) self.assertNotIn(-b, seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
self.assertRaises(TypeError, xrange) self.assertRaises(TypeError, xrange)

42
Lib/test/test_zipfile.py
View file

@ -68,9 +68,9 @@ def zip_test(self, f, compression):
lines = directory.splitlines() lines = directory.splitlines()
self.assertEqual(len(lines), 4) # Number of files + header self.assertEqual(len(lines), 4) # Number of files + header
self.assertTrue('File Name' in lines[0]) self.assertIn('File Name', lines[0])
self.assertTrue('Modified' in lines[0]) self.assertIn('Modified', lines[0])
self.assertTrue('Size' in lines[0]) self.assertIn('Size', lines[0])
fn, date, time_, size = lines[1].split() fn, date, time_, size = lines[1].split()
self.assertEqual(fn, 'another.name') self.assertEqual(fn, 'another.name')
@ -81,17 +81,17 @@ def zip_test(self, f, compression):
# Check the namelist # Check the namelist
names = zipfp.namelist() names = zipfp.namelist()
self.assertEqual(len(names), 3) self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names) self.assertIn(TESTFN, names)
self.assertTrue("another.name" in names) self.assertIn("another.name", names)
self.assertTrue("strfile" in names) self.assertIn("strfile", names)
# Check infolist # Check infolist
infos = zipfp.infolist() infos = zipfp.infolist()
names = [i.filename for i in infos] names = [i.filename for i in infos]
self.assertEqual(len(names), 3) self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names) self.assertIn(TESTFN, names)
self.assertTrue("another.name" in names) self.assertIn("another.name", names)
self.assertTrue("strfile" in names) self.assertIn("strfile", names)
for i in infos: for i in infos:
self.assertEqual(i.file_size, len(self.data)) self.assertEqual(i.file_size, len(self.data))
@ -458,9 +458,9 @@ def zip_test(self, f, compression):
lines = directory.splitlines() lines = directory.splitlines()
self.assertEqual(len(lines), 4) # Number of files + header self.assertEqual(len(lines), 4) # Number of files + header
self.assertTrue('File Name' in lines[0]) self.assertIn('File Name', lines[0])
self.assertTrue('Modified' in lines[0]) self.assertIn('Modified', lines[0])
self.assertTrue('Size' in lines[0]) self.assertIn('Size', lines[0])
fn, date, time_, size = lines[1].split() fn, date, time_, size = lines[1].split()
self.assertEqual(fn, 'another.name') self.assertEqual(fn, 'another.name')
@ -471,17 +471,17 @@ def zip_test(self, f, compression):
# Check the namelist # Check the namelist
names = zipfp.namelist() names = zipfp.namelist()
self.assertEqual(len(names), 3) self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names) self.assertIn(TESTFN, names)
self.assertTrue("another.name" in names) self.assertIn("another.name", names)
self.assertTrue("strfile" in names) self.assertIn("strfile", names)
# Check infolist # Check infolist
infos = zipfp.infolist() infos = zipfp.infolist()
names = [i.filename for i in infos] names = [i.filename for i in infos]
self.assertEqual(len(names), 3) self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names) self.assertIn(TESTFN, names)
self.assertTrue("another.name" in names) self.assertIn("another.name", names)
self.assertTrue("strfile" in names) self.assertIn("strfile", names)
for i in infos: for i in infos:
self.assertEqual(i.file_size, len(self.data)) self.assertEqual(i.file_size, len(self.data))
@ -527,7 +527,7 @@ def test_write_pyfile(self):
zipfp.writepy(fn) zipfp.writepy(fn)
bn = os.path.basename(fn) bn = os.path.basename(fn)
self.assertTrue(bn not in zipfp.namelist()) self.assertNotIn(bn, zipfp.namelist())
self.assertTrue(bn + 'o' in zipfp.namelist() or self.assertTrue(bn + 'o' in zipfp.namelist() or
bn + 'c' in zipfp.namelist()) bn + 'c' in zipfp.namelist())
@ -539,7 +539,7 @@ def test_write_pyfile(self):
zipfp.writepy(fn, "testpackage") zipfp.writepy(fn, "testpackage")
bn = "%s/%s" % ("testpackage", os.path.basename(fn)) bn = "%s/%s" % ("testpackage", os.path.basename(fn))
self.assertTrue(bn not in zipfp.namelist()) self.assertNotIn(bn, zipfp.namelist())
self.assertTrue(bn + 'o' in zipfp.namelist() or self.assertTrue(bn + 'o' in zipfp.namelist() or
bn + 'c' in zipfp.namelist()) bn + 'c' in zipfp.namelist())
@ -576,7 +576,7 @@ def test_write_python_directory(self):
names = zipfp.namelist() names = zipfp.namelist()
self.assertTrue('mod1.pyc' in names or 'mod1.pyo' in names) self.assertTrue('mod1.pyc' in names or 'mod1.pyo' in names)
self.assertTrue('mod2.pyc' in names or 'mod2.pyo' in names) self.assertTrue('mod2.pyc' in names or 'mod2.pyo' in names)
self.assertTrue('mod2.txt' not in names) self.assertNotIn('mod2.txt', names)
finally: finally:
shutil.rmtree(TESTFN2) shutil.rmtree(TESTFN2)

2
Lib/test/test_zipimport.py
View file

@ -297,7 +297,7 @@ def testGetData(self):
z.close() z.close()
zi = zipimport.zipimporter(TEMP_ZIP) zi = zipimport.zipimporter(TEMP_ZIP)
self.assertEquals(data, zi.get_data(name)) self.assertEquals(data, zi.get_data(name))
self.assertTrue('zipimporter object' in repr(zi)) self.assertIn('zipimporter object', repr(zi))
finally: finally:
z.close() z.close()
os.remove(TEMP_ZIP) os.remove(TEMP_ZIP)

8
Lib/test/test_zipimport_support.py
View file

@ -189,7 +189,7 @@ class Test:
print "Expected line", expected print "Expected line", expected
print "Got stdout:" print "Got stdout:"
print data print data
self.assertTrue(expected in data) self.assertIn(expected, data)
zip_name, run_name = make_zip_script(d, "test_zip", zip_name, run_name = make_zip_script(d, "test_zip",
script_name, '__main__.py') script_name, '__main__.py')
exit_code, data = run_python(zip_name) exit_code, data = run_python(zip_name)
@ -198,7 +198,7 @@ class Test:
print "Expected line", expected print "Expected line", expected
print "Got stdout:" print "Got stdout:"
print data print data
self.assertTrue(expected in data) self.assertIn(expected, data)
def test_pdb_issue4201(self): def test_pdb_issue4201(self):
test_src = textwrap.dedent("""\ test_src = textwrap.dedent("""\
@ -213,13 +213,13 @@ def f():
p = spawn_python(script_name) p = spawn_python(script_name)
p.stdin.write('l\n') p.stdin.write('l\n')
data = kill_python(p) data = kill_python(p)
self.assertTrue(script_name in data) self.assertIn(script_name, data)
zip_name, run_name = make_zip_script(d, "test_zip", zip_name, run_name = make_zip_script(d, "test_zip",
script_name, '__main__.py') script_name, '__main__.py')
p = spawn_python(zip_name) p = spawn_python(zip_name)
p.stdin.write('l\n') p.stdin.write('l\n')
data = kill_python(p) data = kill_python(p)
self.assertTrue(run_name in data) self.assertIn(run_name, data)
def test_main(): def test_main():