self.assertEqual(len(d), len(self.reference))
#__contains__
for k in self.reference:
- self.assertTrue(k in d)
+ self.assertIn(k, d)
for k in self.other:
- self.assertFalse(k in d)
+ self.assertNotIn(k, d)
#cmp
self.assertEqual(p, p)
self.assertEqual(d, d)
knownkey, knownvalue = next(iter(self.other.items()))
self.assertEqual(d.get(key, knownvalue), value)
self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
- self.assertFalse(knownkey in d)
+ self.assertNotIn(knownkey, d)
def test_write(self):
# Test for write operations on mapping
self.assertEqual(d[knownkey], knownvalue)
#pop
self.assertEqual(d.pop(knownkey), knownvalue)
- self.assertFalse(knownkey in d)
+ self.assertNotIn(knownkey, d)
self.assertRaises(KeyError, d.pop, knownkey)
default = 909
d[knownkey] = knownvalue
self.assertEqual(d.pop(knownkey, default), knownvalue)
- self.assertFalse(knownkey in d)
+ self.assertNotIn(knownkey, d)
self.assertEqual(d.pop(knownkey, default), default)
#popitem
key, value = d.popitem()
- self.assertFalse(key in d)
+ self.assertNotIn(key, d)
self.assertEqual(value, self.reference[key])
p=self._empty_mapping()
self.assertRaises(KeyError, p.popitem)
d = self._empty_mapping()
self.assertEqual(list(d.keys()), [])
d = self.reference
- self.assertTrue(list(self.inmapping.keys())[0] in d.keys())
- self.assertTrue(list(self.other.keys())[0] not in d.keys())
+ self.assertIn(list(self.inmapping.keys())[0], d.keys())
+ self.assertNotIn(list(self.other.keys())[0], d.keys())
self.assertRaises(TypeError, d.keys, None)
def test_values(self):
self.assertEqual(list(d.keys()), [])
d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys()
- self.assertTrue('a' in k)
- self.assertTrue('b' in k)
- self.assertTrue('c' not in k)
+ self.assertIn('a', k)
+ self.assertIn('b', k)
+ self.assertNotIn('c', k)
def test_values(self):
BasicTestMappingProtocol.test_values(self)
def test_contains(self):
d = self._empty_mapping()
+ self.assertNotIn('a', d)
self.assertTrue(not ('a' in d))
self.assertTrue('a' not in d)
d = self._full_mapping({'a': 1, 'b': 2})
- self.assertTrue('a' in d)
- self.assertTrue('b' in d)
- self.assertTrue('c' not in d)
+ self.assertIn('a', d)
+ self.assertIn('b', d)
+ self.assertNotIn('c', d)
self.assertRaises(TypeError, d.__contains__)
# Dump using protocol 1 for comparison.
s1 = self.dumps(x, 1)
- self.assertTrue(__name__.encode("utf-8") in s1)
- self.assertTrue(b"MyList" in s1)
+ self.assertIn(__name__.encode("utf-8"), s1)
+ self.assertIn(b"MyList", s1)
self.assertEqual(opcode_in_pickle(opcode, s1), False)
y = self.loads(s1)
# Dump using protocol 2 for test.
s2 = self.dumps(x, 2)
- self.assertTrue(__name__.encode("utf-8") not in s2)
- self.assertTrue(b"MyList" not in s2)
+ self.assertNotIn(__name__.encode("utf-8"), s2)
+ self.assertNotIn(b"MyList", s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2))
y = self.loads(s2)
def test_contains(self):
u = self.type2test([0, 1, 2])
for i in u:
- self.assert_(i in u)
+ self.assertIn(i, u)
for i in min(u)-1, max(u)+1:
- self.assert_(i not in u)
+ self.assertNotIn(i, u)
self.assertRaises(TypeError, u.__contains__)
def __eq__(self, other):
return True
__hash__ = None # Can't meet hash invariant requirements
- self.assert_(AllEq() not in self.type2test([]))
- self.assert_(AllEq() in self.type2test([1]))
+ self.assertNotIn(AllEq(), self.type2test([]))
+ self.assertIn(AllEq(), self.type2test([1]))
def test_contains_order(self):
# Sequences must test in-order. If a rich comparison has side
raise DoNotTestEq
checkfirst = self.type2test([1, StopCompares()])
- self.assert_(1 in checkfirst)
+ self.assertIn(1, checkfirst)
checklast = self.type2test([StopCompares(), 1])
self.assertRaises(DoNotTestEq, checklast.__contains__, 1)
s = _('').join([edge, SUBSTR, edge])
del edge
self.assertIn(SUBSTR, s)
- self.assertFalse(SUBSTR * 2 in s)
+ self.assertNotIn(SUBSTR * 2, s)
self.assertIn(_('-'), s)
- self.assertFalse(_('a') in s)
+ self.assertNotIn(_('a'), s)
s += _('a')
self.assertIn(_('a'), s)
t = (1, 2, 3, 4, 5) * size
self.assertEquals(len(t), size * 5)
self.assertIn(5, t)
- self.assertFalse((1, 2, 3, 4, 5) in t)
- self.assertFalse(0 in t)
+ self.assertNotIn((1, 2, 3, 4, 5), t)
+ self.assertNotIn(0, t)
@bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size):
l = [1, 2, 3, 4, 5] * size
self.assertEquals(len(l), size * 5)
self.assertIn(5, l)
- self.assertFalse([1, 2, 3, 4, 5] in l)
- self.assertFalse(0 in l)
+ self.assertNotIn([1, 2, 3, 4, 5], l)
+ self.assertNotIn(0, l)
@bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size):
b = self.type2test(b"abc")
self.assertIn(ord('a'), b)
self.assertIn(int(ord('a')), b)
- self.assertFalse(200 in b)
- self.assertFalse(200 in b)
+ self.assertNotIn(200, b)
self.assertRaises(ValueError, lambda: 300 in b)
self.assertRaises(ValueError, lambda: -1 in b)
self.assertRaises(TypeError, lambda: None in b)
self.assertIn(f(b"ab"), b)
self.assertIn(f(b"bc"), b)
self.assertIn(f(b"abc"), b)
- self.assertFalse(f(b"ac") in b)
- self.assertFalse(f(b"d") in b)
- self.assertFalse(f(b"dab") in b)
- self.assertFalse(f(b"abd") in b)
+ self.assertNotIn(f(b"ac"), b)
+ self.assertNotIn(f(b"d"), b)
+ self.assertNotIn(f(b"dab"), b)
+ self.assertNotIn(f(b"abd"), b)
def test_fromhex(self):
self.assertRaises(TypeError, self.type2test.fromhex)
eq(cf.get('Spaces', 'key with spaces'), 'value')
eq(cf.get('Spaces', 'another with spaces'), 'splat!')
- self.assertFalse('__name__' in cf.options("Foo Bar"),
- '__name__ "option" should not be exposed by the API!')
+ self.assertNotIn('__name__', cf.options("Foo Bar"),
+ '__name__ "option" should not be exposed by the API!')
# Make sure the right things happen for remove_option();
# added to include check for SourceForge bug #123324:
self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
self.assertEqual(c.pop('f'), 4)
- self.assertEqual('f' in c, False)
+ self.assertNotIn('f', c)
for i in range(3):
elem, cnt = c.popitem()
- self.assertEqual(elem in c, False)
+ self.assertNotIn(elem, c)
c.clear()
self.assertEqual(c, {})
self.assertEqual(repr(c), 'Counter()')
d[1] += 1
self.assertEqual(d[1], 2)
del d[1]
- self.assertEqual(1 in d, False)
+ self.assertNotIn(1, d)
# Tuple of indices
d[1, 1] = 1
self.assertEqual(d[1, 1], 1)
d[1, 1] += 1
self.assertEqual(d[1, 1], 2)
del d[1, 1]
- self.assertEqual((1, 1) in d, False)
+ self.assertNotIn((1, 1), d)
# Simple slice
d[1:2] = 1
self.assertEqual(d[1:2], 1)
d[1:2] += 1
self.assertEqual(d[1:2], 2)
del d[1:2]
- self.assertEqual(slice(1, 2) in d, False)
+ self.assertNotIn(slice(1, 2), d)
# Tuple of simple slices
d[1:2, 1:2] = 1
self.assertEqual(d[1:2, 1:2], 1)
d[1:2, 1:2] += 1
self.assertEqual(d[1:2, 1:2], 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
d[1:2:3] = 1
self.assertEqual(d[1:2:3], 1)
d[1:2:3] += 1
self.assertEqual(d[1:2:3], 2)
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
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
self.assertEqual(d[1:2:3, 1:2:3], 2)
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
d[...] = 1
self.assertEqual(d[...], 1)
d[...] += 1
self.assertEqual(d[...], 2)
del d[...]
- self.assertEqual(Ellipsis in d, False)
+ self.assertNotIn(Ellipsis, d)
# Tuple of Ellipses
d[..., ...] = 1
self.assertEqual(d[..., ...], 1)
d[..., ...] += 1
self.assertEqual(d[..., ...], 2)
del d[..., ...]
- self.assertEqual((Ellipsis, Ellipsis) in d, False)
+ self.assertNotIn((Ellipsis, Ellipsis), d)
def test_annotation_limit(self):
# 16 bits are available for # of annotations, but only 8 bits are
x, y = C(), C()
# The underlying containers are decoupled
v[x] = y
- self.assertFalse(x in u)
+ self.assertNotIn(x, u)
def test_copy_weakkeydict(self):
self._check_copy_weakdict(weakref.WeakKeyDictionary)
self.assertTrue(() != me)
self.assertIn(me, [1, 20, [], me])
- self.assertFalse(me not in [1, 20, [], me])
-
self.assertIn([], [me, 1, 20, []])
- self.assertFalse([] not in [me, 1, 20, []])
def test_harmful_mixed_comparison(self):
me = self.theclass(1, 1, 1)
self.init_db()
f = dbm.open(_fname, 'r')
key = "a".encode("ascii")
- assert(key in f)
+ self.assertIn(key, f)
assert(f[key] == b"Python:")
f.close()
self.assertNotIn(-1, c1)
for i in range(10):
self.assertIn(i, c1)
- self.assertFalse(10 in c1)
+ self.assertNotIn(10, c1)
# Test the default behavior for dynamic classes
class D(object):
def __getitem__(self, i):
self.assertNotIn(-1, d1)
for i in range(10):
self.assertIn(i, d1)
- self.assertFalse(10 in d1)
+ self.assertNotIn(10, d1)
# Test overridden behavior
class Proxy(object):
def __init__(self, x):
self.assertEqual(str(p0), "Proxy:0")
self.assertEqual(repr(p0), "Proxy(0)")
p10 = Proxy(range(10))
- self.assertFalse(-1 in p10)
+ self.assertNotIn(-1, p10)
for i in range(10):
self.assertIn(i, p10)
- self.assertFalse(10 in p10)
+ self.assertNotIn(10, p10)
def test_weakrefs(self):
# Testing weak references...
self.assertEqual(set(d.keys()), set())
d = {'a': 1, 'b': 2}
k = d.keys()
- self.assertTrue('a' in d)
self.assertIn('a', d)
- self.assertTrue('b' in d)
self.assertIn('b', d)
self.assertRaises(TypeError, d.keys, None)
self.assertEqual(repr(dict(a=1).keys()), "dict_keys(['a'])")
def test_contains(self):
d = {}
+ self.assertNotIn('a', d)
self.assertTrue(not ('a' in d))
self.assertTrue('a' not in d)
- self.assertNotIn('a', d)
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__)
d = D({1: 2, 3: 4})
self.assertEqual(d[1], 2)
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)
class E(dict):
def test_opmap(self):
self.assertEqual(dis.opmap["STOP_CODE"], 0)
- self.assertEqual(dis.opmap["LOAD_CONST"] in dis.hasconst, True)
- self.assertEqual(dis.opmap["STORE_NAME"] in dis.hasname, True)
+ self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
+ self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
def test_opname(self):
self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
serv.set_server_title("DocXMLRPCServer Test Documentation")
serv.set_server_name("DocXMLRPCServer Test Docs")
serv.set_server_documentation(
-"""This is an XML-RPC server's documentation, but the server can be used by
-POSTing to /RPC2. Try self.add, too.""")
+ "This is an XML-RPC server's documentation, but the server "
+ "can be used by POSTing to /RPC2. Try self.add, too.")
# Create and register classes and functions
class TestClass(object):
self.client.request("GET", "/")
response = self.client.getresponse()
- self.assertTrue(
-b"""<dl><dt><a name="-<lambda>"><strong><lambda></strong></a>(x, y)</dt></dl>"""
- in response.read())
+ self.assertIn((b'<dl><dt><a name="-<lambda>"><strong>'
+ b'<lambda></strong></a>(x, y)</dt></dl>'),
+ response.read())
def test_autolinking(self):
"""Test that the server correctly automatically wraps references to PEPS
self.client.request("GET", "/")
response = self.client.getresponse().read()
- self.assertTrue( # This is ugly ... how can it be made better?
-b"""<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd><tt>Add two instances together. This follows <a href="http://www.python.org/dev/peps/pep-0008/">PEP008</a>, but has nothing<br>\nto do with <a href="http://www.rfc-editor.org/rfc/rfc1952.txt">RFC1952</a>. Case should matter: pEp008 and rFC1952. Things<br>\nthat start with http and ftp should be auto-linked, too:<br>\n<a href="http://google.com">http://google.com</a>.</tt></dd></dl>"""
- in response, response)
+ self.assertIn(
+ (b'<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd>'
+ b'<tt>Add two instances together. This '
+ b'follows <a href="http://www.python.org/dev/peps/pep-0008/">'
+ b'PEP008</a>, but has nothing<br>\nto do '
+ b'with <a href="http://www.rfc-editor.org/rfc/rfc1952.txt">'
+ b'RFC1952</a>. Case should matter: pEp008 '
+ b'and rFC1952. Things<br>\nthat start '
+ b'with http and ftp should be '
+ b'auto-linked, too:<br>\n<a href="http://google.com">'
+ b'http://google.com</a>.</tt></dd></dl>'), response)
def test_system_methods(self):
"""Test the precense of three consecutive system.* methods.
self.client.request("GET", "/")
response = self.client.getresponse().read()
- self.assertTrue(
-b"""<dl><dt><a name="-system.methodHelp"><strong>system.methodHelp</strong></a>(method_name)</dt><dd><tt><a href="#-system.methodHelp">system.methodHelp</a>(\'add\') => "Adds two integers together"<br>\n <br>\nReturns a string containing documentation for the specified 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\') => [double, int, int]<br>\n <br>\nReturns a list describing the signature of the method. In the<br>\nabove example, the add method takes two integers as arguments<br>\nand returns a double result.<br>\n <br>\nThis server does NOT support system.methodSignature.</tt></dd></dl>\n<dl><dt><a name="-test_method"><strong>test_method</strong></a>(arg)</dt><dd><tt>Test method\'s docs. This method truly does very little.</tt></dd></dl>""" in response)
+ self.assertIn(
+ (b'<dl><dt><a name="-system.methodHelp"><strong>system.methodHelp'
+ b'</strong></a>(method_name)</dt><dd><tt><a href="#-system.method'
+ b'Help">system.methodHelp</a>(\'add\') => "Adds '
+ b'two integers together"<br>\n <br>\nReturns a'
+ b' string containing documentation for '
+ b'the specified method.</tt></dd></dl>\n<dl><dt><a name'
+ b'="-system.methodSignature"><strong>system.methodSignature</strong>'
+ b'</a>(method_name)</dt><dd><tt><a href="#-system.methodSignature">'
+ b'system.methodSignature</a>(\'add\') => [double, '
+ b'int, int]<br>\n <br>\nReturns a list '
+ b'describing the signature of the method.'
+ b' In the<br>\nabove example, the add '
+ b'method takes two integers as arguments'
+ b'<br>\nand returns a double result.<br>\n '
+ b'<br>\nThis server does NOT support system'
+ b'.methodSignature.</tt></dd></dl>\n<dl><dt><a name="-test_method">'
+ b'<strong>test_method</strong></a>(arg)</dt><dd><tt>Test '
+ b'method\'s docs. This method truly does'
+ b' very little.</tt></dd></dl>'), response)
def test_autolink_dotted_methods(self):
"""Test that selfdot values are made strong automatically in the
self.client.request("GET", "/")
response = self.client.getresponse()
- self.assertTrue(b"""Try self.<strong>add</strong>, too.""" in
- response.read())
+ self.assertIn(b"""Try self.<strong>add</strong>, too.""",
+ response.read())
def test_main():
support.run_unittest(DocXMLRPCHTTPGETServer)
def test_attributes_in_errorcode(self):
for attribute in errno.__dict__.keys():
if attribute.isupper():
- self.assertTrue(getattr(errno, attribute) in errno.errorcode,
- 'no %s attr in errno.errorcode' % attribute)
+ self.assertIn(getattr(errno, attribute), errno.errorcode,
+ 'no %s attr in errno.errorcode' % attribute)
def test_main():
except Exception as e:
self.assertTrue(e)
del e
- self.assertFalse('e' in locals())
+ self.assertNotIn('e', locals())
def testExceptionCleanupState(self):
# Make sure exception state is cleaned up as soon as the except
floats = (INF, -INF, 0.0, 1.0, NAN)
for f in floats:
self.assertIn(f, [f])
- self.assertTrue(f in [f], "'%r' not in []" % f)
self.assertIn(f, (f,))
- self.assertTrue(f in (f,), "'%r' not in ()" % f)
self.assertIn(f, {f})
- self.assertTrue(f in {f}, "'%r' not in set()" % f)
self.assertIn(f, {f: None})
- self.assertTrue(f in {f: None}, "'%r' not in {}" % f)
self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
self.assertIn(f, floats)
- self.assertTrue(f in floats, "'%r' not in container" % f)
for f in floats:
# nonidentical containers, same type, same contents
float.__setformat__('float', self.save_formats['float'])
def test_getformat(self):
- self.assertTrue(float.__getformat__('double') in
- ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
- self.assertTrue(float.__getformat__('float') in
- ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
+ self.assertIn(float.__getformat__('double'),
+ ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
+ self.assertIn(float.__getformat__('float'),
+ ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
self.assertRaises(ValueError, float.__getformat__, 'chicken')
self.assertRaises(TypeError, float.__getformat__, 1)
url = "http://foo.bar.com/"
interact_2965(c, url, "spam=eggs; Version=1")
h = interact_2965(c, url)
- self.assertTrue("Path" not in h,
- "absent path returned with path present")
+ self.assertNotIn("Path", h, "absent path returned with path present")
c = CookieJar(pol)
url = "http://foo.bar.com/"
url = "http://foo.bar.com/"
interact_2965(c, url, "spam=eggs; Version=1")
h = interact_2965(c, url)
- self.assertTrue("Port" not in h,
- "absent port returned with port present")
+ self.assertNotIn("Port", h, "absent port returned with port present")
c = CookieJar(pol)
url = "http://foo.bar.com/"
url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Port="80"')
h = interact_2965(c, url)
- self.assertTrue('$Port="80"' in h,
- "port with single value not returned with single value")
+ self.assertIn('$Port="80"', h,
+ "port with single value not returned with single value")
c = CookieJar(pol)
url = "http://foo.bar.com/"
interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"')
h = interact_2965(c, url)
- self.assertTrue('$Port="80,8080"' in h,
- "port with multiple values not returned with multiple "
- "values")
+ self.assertIn('$Port="80,8080"', h,
+ "port with multiple values not returned with multiple "
+ "values")
def test_no_return_comment(self):
c = CookieJar(DefaultCookiePolicy(rfc2965=True))
c.add_cookie_header(req)
h = req.get_header("Cookie")
- self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
- "CUSTOMER=WILE_E_COYOTE" in h)
+ self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
+ self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo')
res = FakeResponse(headers, "http://www.acme.com")
c.add_cookie_header(req)
h = req.get_header("Cookie")
- self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
- "CUSTOMER=WILE_E_COYOTE" in h and
- "SHIPPING=FEDEX" not in h)
+ self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
+ self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
+ self.assertNotIn("SHIPPING=FEDEX", h)
req = urllib.request.Request("http://www.acme.com/foo/")
c.add_cookie_header(req)
h = req.get_header("Cookie")
- self.assertTrue(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
- "CUSTOMER=WILE_E_COYOTE" in h and
- h.startswith("SHIPPING=FEDEX;")))
+ self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
+ self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
+ self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
def test_netscape_example_2(self):
# Second Example transaction sequence:
# the server.
cookie = interact_2965(c, "http://www.acme.com/acme/parts/")
- self.assertTrue("Rocket_Launcher_0001" in cookie and
- "Riding_Rocket_0023" not in cookie)
+ self.assertIn("Rocket_Launcher_0001", cookie)
+ self.assertNotIn("Riding_Rocket_0023", cookie)
def test_rejection(self):
# Test rejection of Set-Cookie2 responses based on domain, path, port.
self.assertIn(('s', 'static method', A), attrs, 'missing static method')
self.assertIn(('c', 'class method', A), attrs, 'missing class method')
self.assertIn(('p', 'property', A), attrs, 'missing property')
- self.assertTrue(('m', 'method', A) in attrs,
- 'missing plain method: %r' % attrs)
+ self.assertIn(('m', 'method', A), attrs,
+ 'missing plain method: %r' % attrs)
self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
self.assertIn(('datablob', 'data', A), attrs, 'missing data')
Subclass(newarg=1)
except TypeError as err:
# 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
self.assertEqual(iso2022jp2.decode('iso2022-jp-2'), uni)
def test_iso2022_jp_g0(self):
- self.assertFalse(b'\x0e' in '\N{SOFT HYPHEN}'.encode('iso-2022-jp-2'))
+ self.assertNotIn(b'\x0e', '\N{SOFT HYPHEN}'.encode('iso-2022-jp-2'))
for encoding in ('iso-2022-jp-2004', 'iso-2022-jp-3'):
e = '\u3406'.encode(encoding)
self.assertFalse(any(x > 0x80 for x in e))
last_exc = getattr(builtins, superclass_name)
except AttributeError:
self.fail("base class %s not a built-in" % superclass_name)
- self.assertTrue(superclass_name in exc_set,
- '%s not found' % superclass_name)
+ self.assertIn(superclass_name, exc_set,
+ '%s not found' % superclass_name)
exc_set.discard(superclass_name)
superclasses = [] # Loop will insert base exception
last_depth = 0
self.rewrite_file('for')
try: __import__(self.module_name)
except SyntaxError: pass
- else: raise RuntimeError('Failed to induce SyntaxError')
- self.assertTrue(self.module_name not in sys.modules and
- not hasattr(sys.modules[self.package_name], 'foo'))
+ else: raise RuntimeError('Failed to induce SyntaxError') # self.fail()?
+ self.assertNotIn(self.module_name, sys.modules)
+ self.assertFalse(hasattr(sys.modules[self.package_name], 'foo'))
# ...make up a variable name that isn't bound in __builtins__
var = 'a'
stats = pstats.Stats(prof, stream=s)
stats.print_stats()
res = s.getvalue()
- self.assertTrue(self.expected_max_output in res,
+ self.assertIn(self.expected_max_output, res,
"Profiling {0!r} didn't report max:\n{1}".format(stmt, res))
if key not in obj:
print("***",key, file=sys.stderr)
self.assertIn(key, obj)
- self.assertTrue(key in obj, "%r in %r" % (key, obj))
def assertEqualsOrIgnored(self, a, b, ignore):
''' succeed iff a == b or a in ignore or b in ignore '''
class C2:
def __int__(self): return 1
def __index__(self): return 1
- self.assertFalse(C2() in range(3))
+ self.assertNotIn(C2(), range(3))
# ..except if explicitly told so.
self.assertIn(int(C2()), range(3))
def test_strided_limits(self):
r = range(0, 101, 2)
self.assertIn(0, r)
- self.assertFalse(1 in r)
+ self.assertNotIn(1, r)
self.assertIn(2, r)
- self.assertFalse(99 in r)
+ self.assertNotIn(99, r)
self.assertIn(100, r)
- self.assertFalse(101 in r)
+ self.assertNotIn(101, r)
r = range(0, -20, -1)
self.assertIn(0, r)
self.assertIn(-1, r)
self.assertIn(-19, r)
- self.assertFalse(-20 in r)
+ self.assertNotIn(-20, r)
r = range(0, -20, -2)
self.assertIn(-18, r)
- self.assertFalse(-19 in r)
- self.assertFalse(-20 in r)
+ self.assertNotIn(-19, r)
+ self.assertNotIn(-20, r)
def test_empty(self):
r = range(0)
- self.assertFalse(0 in r)
- self.assertFalse(1 in r)
+ self.assertNotIn(0, r)
+ self.assertNotIn(1, r)
r = range(0, -10)
- self.assertFalse(0 in r)
- self.assertFalse(-1 in r)
- self.assertFalse(1 in r)
+ self.assertNotIn(0, r)
+ self.assertNotIn(-1, r)
+ self.assertNotIn(1, r)
def test_range_iterators(self):
# exercise 'fast' iterators, that use a rangeiterobject internally.
self.assertEquals(attrs.getNames(), [])
self.assertEquals(attrs.getQNames(), [])
self.assertEquals(len(attrs), 0)
- self.assertFalse("attr" in attrs)
+ self.assertNotIn("attr", attrs)
self.assertEquals(list(attrs.keys()), [])
self.assertEquals(attrs.get("attrs"), None)
self.assertEquals(attrs.get("attrs", 25), 25)
self.assertEquals(attrs.getNames(), [])
self.assertEquals(attrs.getQNames(), [])
self.assertEquals(len(attrs), 0)
- self.assertFalse((ns_uri, "attr") in attrs)
+ self.assertNotIn((ns_uri, "attr"), attrs)
self.assertEquals(list(attrs.keys()), [])
self.assertEquals(attrs.get((ns_uri, "attr")), None)
self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
dir_set = site._init_pathinfo()
for entry in [site.makepath(path)[1] for path in sys.path
if path and os.path.isdir(path)]:
- self.assertTrue(entry in dir_set,
- "%s from sys.path not found in set returned "
- "by _init_pathinfo(): %s" % (entry, dir_set))
+ self.assertIn(entry, dir_set,
+ "%s from sys.path not found in set returned "
+ "by _init_pathinfo(): %s" % (entry, dir_set))
def pth_file_tests(self, pth_file):
"""Contain common code for testing results of reading a .pth file"""
- self.assertTrue(pth_file.imported in sys.modules,
- "%s not in sys.modules" % pth_file.imported)
+ self.assertIn(pth_file.imported, sys.modules,
+ "%s not in sys.modules" % pth_file.imported)
self.assertIn(site.makepath(pth_file.good_dir_path)[0], sys.path)
self.assertFalse(os.path.exists(pth_file.bad_dir_path))
"""
strftime_output = time.strftime(directive, self.time_tuple).lower()
comparison = testing[self.time_tuple[tuple_position]]
- self.assertTrue(strftime_output in testing, "%s: not found in tuple" %
- error_msg)
+ self.assertIn(strftime_output, testing,
+ "%s: not found in tuple" % error_msg)
self.assertTrue(comparison == strftime_output,
"%s: position within tuple incorrect; %s != %s" %
(error_msg, comparison, strftime_output))
def test_am_pm(self):
# Make sure AM/PM representation done properly
strftime_output = time.strftime("%p", self.time_tuple).lower()
- self.assertTrue(strftime_output in self.LT_ins.am_pm,
- "AM/PM representation not in tuple")
+ self.assertIn(strftime_output, self.LT_ins.am_pm,
+ "AM/PM representation not in tuple")
if self.time_tuple[3] < 12: position = 0
else: position = 1
self.assertTrue(strftime_output == self.LT_ins.am_pm[position],
# Make sure timezone is correct
timezone = time.strftime("%Z", self.time_tuple).lower()
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 %s not found in %s" %
(timezone, self.LT_ins.timezone))
# Make sure any characters in the format string that might be taken as
# regex syntax is escaped.
pattern_string = self.time_re.pattern("\d+")
- self.assertTrue(r"\\d\+" in pattern_string,
- "%s does not have re characters escaped properly" %
- pattern_string)
+ self.assertIn(r"\\d\+", pattern_string,
+ "%s does not have re characters escaped properly" %
+ pattern_string)
def test_compile(self):
# Check that compiled regex is correct
self.assertTrue(isinstance(vi.major, int))
self.assertTrue(isinstance(vi.minor, int))
self.assertTrue(isinstance(vi.micro, int))
- self.assertTrue(vi.releaselevel in
- ("alpha", "beta", "candidate", "final"))
+ self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertTrue(isinstance(vi.serial, int))
self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor)
for i in range(TEST_FILES):
s = next(r)
self.nameCheck(s, '', '', '')
- self.assertFalse(s in dict)
+ self.assertNotIn(s, dict)
dict[s] = 1
def supports_iter(self):
t.start()
t.join()
l = enum()
- self.assertFalse(t in l,
+ self.assertNotIn(t, l,
"#1703448 triggered after %d trials: %s" % (i, l))
finally:
sys.setswitchinterval(old_interval)
err_line = "raise RuntimeError('{0}')".format(message_ascii)
err_msg = "RuntimeError: {0}".format(message_ascii)
- self.assertTrue(("line %s" % lineno) in stdout[1],
+ self.assertIn(("line %s" % lineno), stdout[1],
"Invalid line number: {0!r} instead of {1}".format(
stdout[1], lineno))
self.assertTrue(stdout[2].endswith(err_line),
self.assertEquals(len(blocks), 3)
self.assertEquals(blocks[1], cause_message)
self.check_zero_div(blocks[0])
- self.assert_('inner_raise() # Marker' in blocks[2])
+ self.assertIn('inner_raise() # Marker', blocks[2])
def test_cause_recursive(self):
def inner_raise():
try:
self.assertRaises(KeyError, lambda: None)
except self.failureException as e:
- self.assert_("KeyError not raised" in str(e), str(e))
+ self.assertIn("KeyError not raised", str(e))
else:
self.fail("assertRaises() didn't fail")
try:
with self.assertRaises(KeyError):
pass
except self.failureException as e:
- self.assert_("KeyError not raised" in str(e), str(e))
+ self.assertIn("KeyError not raised", str(e))
else:
self.fail("assertRaises() didn't fail")
try:
expect_somewhere = ["1st=1", "2nd=2", "3rd=3"]
result = urllib.parse.urlencode(given)
for expected in expect_somewhere:
- self.assertTrue(expected in result,
+ self.assertIn(expected, result,
"testing %s: %s not found in %s" %
(test_type, expected, result))
self.assertEqual(result.count('&'), 2,
result = urllib.parse.urlencode(given, True)
for value in given["sequence"]:
expect = "sequence=%s" % value
- self.assertTrue(expect in result,
- "%s not found in %s" % (expect, result))
+ self.assertIn(expect, result)
self.assertEqual(result.count('&'), 2,
"Expected 2 '&'s, got %s" % result.count('&'))
# Verify Proxy-Authorization gets tunneled to request.
# httpsconn req_headers do not have the Proxy-Authorization header but
# the req will have.
- self.assertFalse(("Proxy-Authorization","FooBar") in
+ self.assertNotIn(("Proxy-Authorization","FooBar"),
https_handler.httpconn.req_headers)
- self.assertTrue(("User-Agent","Grail") in
- https_handler.httpconn.req_headers)
+ self.assertIn(("User-Agent","Grail"),
+ https_handler.httpconn.req_headers)
self.assertIsNotNone(req._tunnel_host)
self.assertEqual(req.get_host(), "proxy.example.com:3128")
self.assertEqual(req.get_header("Proxy-authorization"),"FooBar")
p[:] = [2, 3]
self.assertEqual(len(L), 2)
self.assertEqual(len(p), 2)
- self.assertTrue(3 in p,
- "proxy didn't support __contains__() properly")
+ self.assertIn(3, p, "proxy didn't support __contains__() properly")
p[1] = 5
self.assertEqual(L[1], 5)
self.assertEqual(p[1], 5)
# weakref'ed objects and then return a new key/value pair corresponding
# to the destroyed object.
with testcontext() as (k, v):
- self.assertFalse(k in dict)
+ self.assertNotIn(k, dict)
with testcontext() as (k, v):
self.assertRaises(KeyError, dict.__delitem__, k)
- self.assertFalse(k in dict)
+ self.assertNotIn(k, dict)
with testcontext() as (k, v):
self.assertRaises(KeyError, dict.pop, k)
- self.assertFalse(k in dict)
+ self.assertNotIn(k, dict)
with testcontext() as (k, v):
dict[k] = v
self.assertEqual(dict[k], v)
weakdict.update(dict)
self.assertEqual(len(weakdict), len(dict))
for k in weakdict.keys():
- self.assertTrue(k in dict,
- "mysterious new key appeared in weak dict")
+ self.assertIn(k, dict, "mysterious new key appeared in weak dict")
v = dict.get(k)
self.assertTrue(v is weakdict[k])
self.assertTrue(v is weakdict.get(k))
for k in dict.keys():
- self.assertTrue(k in weakdict,
- "original key disappeared in weak dict")
+ self.assertIn(k, weakdict, "original key disappeared in weak dict")
v = dict[k]
self.assertTrue(v is weakdict[k])
self.assertTrue(v is weakdict.get(k))
for method in dir(set):
if method == 'test_c_api' or method.startswith('_'):
continue
- self.assertTrue(method in weaksetmethods,
+ self.assertIn(method, weaksetmethods,
"WeakSet missing method " + method)
def test_new_or_init(self):
it = None # should commit all removals
with testcontext() as u:
- self.assertFalse(u in s)
+ self.assertNotIn(u, s)
with testcontext() as u:
self.assertRaises(KeyError, s.remove, u)
- self.assertFalse(u in s)
+ self.assertNotIn(u, s)
with testcontext() as u:
s.add(u)
self.assertIn(u, s)
projects / python / commitdiff