Merged revisions 86596 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/py3k
........
r86596 | ezio.melotti | 2010-11-20 21:04:17 +0200 (Sat, 20 Nov 2010) | 1 line
#9424: Replace deprecated assert* methods in the Python test suite.
........
diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py
index 58689cd..6d20f7d 100644
--- a/Lib/test/buffer_tests.py
+++ b/Lib/test/buffer_tests.py
@@ -15,32 +15,32 @@
def test_islower(self):
self.assertFalse(self.marshal(b'').islower())
- self.assert_(self.marshal(b'a').islower())
+ self.assertTrue(self.marshal(b'a').islower())
self.assertFalse(self.marshal(b'A').islower())
self.assertFalse(self.marshal(b'\n').islower())
- self.assert_(self.marshal(b'abc').islower())
+ self.assertTrue(self.marshal(b'abc').islower())
self.assertFalse(self.marshal(b'aBc').islower())
- self.assert_(self.marshal(b'abc\n').islower())
+ self.assertTrue(self.marshal(b'abc\n').islower())
self.assertRaises(TypeError, self.marshal(b'abc').islower, 42)
def test_isupper(self):
self.assertFalse(self.marshal(b'').isupper())
self.assertFalse(self.marshal(b'a').isupper())
- self.assert_(self.marshal(b'A').isupper())
+ self.assertTrue(self.marshal(b'A').isupper())
self.assertFalse(self.marshal(b'\n').isupper())
- self.assert_(self.marshal(b'ABC').isupper())
+ self.assertTrue(self.marshal(b'ABC').isupper())
self.assertFalse(self.marshal(b'AbC').isupper())
- self.assert_(self.marshal(b'ABC\n').isupper())
+ self.assertTrue(self.marshal(b'ABC\n').isupper())
self.assertRaises(TypeError, self.marshal(b'abc').isupper, 42)
def test_istitle(self):
self.assertFalse(self.marshal(b'').istitle())
self.assertFalse(self.marshal(b'a').istitle())
- self.assert_(self.marshal(b'A').istitle())
+ self.assertTrue(self.marshal(b'A').istitle())
self.assertFalse(self.marshal(b'\n').istitle())
- self.assert_(self.marshal(b'A Titlecased Line').istitle())
- self.assert_(self.marshal(b'A\nTitlecased Line').istitle())
- self.assert_(self.marshal(b'A Titlecased, Line').istitle())
+ self.assertTrue(self.marshal(b'A Titlecased Line').istitle())
+ self.assertTrue(self.marshal(b'A\nTitlecased Line').istitle())
+ self.assertTrue(self.marshal(b'A Titlecased, Line').istitle())
self.assertFalse(self.marshal(b'Not a capitalized String').istitle())
self.assertFalse(self.marshal(b'Not\ta Titlecase String').istitle())
self.assertFalse(self.marshal(b'Not--a Titlecase String').istitle())
@@ -50,31 +50,31 @@
def test_isspace(self):
self.assertFalse(self.marshal(b'').isspace())
self.assertFalse(self.marshal(b'a').isspace())
- self.assert_(self.marshal(b' ').isspace())
- self.assert_(self.marshal(b'\t').isspace())
- self.assert_(self.marshal(b'\r').isspace())
- self.assert_(self.marshal(b'\n').isspace())
- self.assert_(self.marshal(b' \t\r\n').isspace())
+ self.assertTrue(self.marshal(b' ').isspace())
+ self.assertTrue(self.marshal(b'\t').isspace())
+ self.assertTrue(self.marshal(b'\r').isspace())
+ self.assertTrue(self.marshal(b'\n').isspace())
+ self.assertTrue(self.marshal(b' \t\r\n').isspace())
self.assertFalse(self.marshal(b' \t\r\na').isspace())
self.assertRaises(TypeError, self.marshal(b'abc').isspace, 42)
def test_isalpha(self):
self.assertFalse(self.marshal(b'').isalpha())
- self.assert_(self.marshal(b'a').isalpha())
- self.assert_(self.marshal(b'A').isalpha())
+ self.assertTrue(self.marshal(b'a').isalpha())
+ self.assertTrue(self.marshal(b'A').isalpha())
self.assertFalse(self.marshal(b'\n').isalpha())
- self.assert_(self.marshal(b'abc').isalpha())
+ self.assertTrue(self.marshal(b'abc').isalpha())
self.assertFalse(self.marshal(b'aBc123').isalpha())
self.assertFalse(self.marshal(b'abc\n').isalpha())
self.assertRaises(TypeError, self.marshal(b'abc').isalpha, 42)
def test_isalnum(self):
self.assertFalse(self.marshal(b'').isalnum())
- self.assert_(self.marshal(b'a').isalnum())
- self.assert_(self.marshal(b'A').isalnum())
+ self.assertTrue(self.marshal(b'a').isalnum())
+ self.assertTrue(self.marshal(b'A').isalnum())
self.assertFalse(self.marshal(b'\n').isalnum())
- self.assert_(self.marshal(b'123abc456').isalnum())
- self.assert_(self.marshal(b'a1b3c').isalnum())
+ self.assertTrue(self.marshal(b'123abc456').isalnum())
+ self.assertTrue(self.marshal(b'a1b3c').isalnum())
self.assertFalse(self.marshal(b'aBc000 ').isalnum())
self.assertFalse(self.marshal(b'abc\n').isalnum())
self.assertRaises(TypeError, self.marshal(b'abc').isalnum, 42)
@@ -82,8 +82,8 @@
def test_isdigit(self):
self.assertFalse(self.marshal(b'').isdigit())
self.assertFalse(self.marshal(b'a').isdigit())
- self.assert_(self.marshal(b'0').isdigit())
- self.assert_(self.marshal(b'0123456789').isdigit())
+ self.assertTrue(self.marshal(b'0').isdigit())
+ self.assertTrue(self.marshal(b'0123456789').isdigit())
self.assertFalse(self.marshal(b'0123456789a').isdigit())
self.assertRaises(TypeError, self.marshal(b'abc').isdigit, 42)
diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py
index 03a4d6f..a69653b 100644
--- a/Lib/test/fork_wait.py
+++ b/Lib/test/fork_wait.py
@@ -38,8 +38,8 @@
break
time.sleep(2 * SHORTSLEEP)
- self.assertEquals(spid, cpid)
- self.assertEquals(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
+ self.assertEqual(spid, cpid)
+ self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
def test_wait(self):
for i in range(NUM_THREADS):
@@ -48,7 +48,7 @@
time.sleep(LONGSLEEP)
a = sorted(self.alive.keys())
- self.assertEquals(a, list(range(NUM_THREADS)))
+ self.assertEqual(a, list(range(NUM_THREADS)))
prefork_lives = self.alive.copy()
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index 12f4e8f..e3a7845 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -337,7 +337,7 @@
self.assertRaises(BadExc, d.remove, 'c')
for x, y in zip(d, e):
# verify that original order and values are retained.
- self.assert_(x is y)
+ self.assertIs(x, y)
def test_count(self):
a = self.type2test([0, 1, 2])*3
@@ -482,7 +482,7 @@
u = self.type2test([0, 1])
u2 = u
u += [2, 3]
- self.assert_(u is u2)
+ self.assertIs(u, u2)
u = self.type2test("spam")
u += "eggs"
diff --git a/Lib/test/outstanding_bugs.py b/Lib/test/outstanding_bugs.py
index 9e4784c..0849ee5 100644
--- a/Lib/test/outstanding_bugs.py
+++ b/Lib/test/outstanding_bugs.py
@@ -35,7 +35,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_2(self):
txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII")
@@ -47,7 +47,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_3(self):
txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII")
@@ -58,7 +58,7 @@
reads += txt.readline()
reads += txt.readline()
reads += txt.readline()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_4(self):
txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII")
@@ -66,7 +66,7 @@
reads = txt.read(4)
reads += txt.read()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_5(self):
txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII")
@@ -76,7 +76,7 @@
pos = txt.tell()
txt.seek(0)
txt.seek(pos)
- self.assertEquals(txt.read(4), "BBB\n")
+ self.assertEqual(txt.read(4), "BBB\n")
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index 25af97d..06789cd 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -564,7 +564,7 @@
def test_get(self):
self.assertRaises(KeyError, self.loads, b'g0\np0')
- self.assertEquals(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)])
+ self.assertEqual(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)])
def test_insecure_strings(self):
# XXX Some of these tests are temporarily disabled
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 5148d4b..f655c29 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -131,8 +131,8 @@
self.assertRaises(ZeroDivisionError, self.type2test, IterGenExc(s))
def test_truth(self):
- self.assert_(not self.type2test())
- self.assert_(self.type2test([42]))
+ self.assertFalse(self.type2test())
+ self.assertTrue(self.type2test([42]))
def test_getitem(self):
u = self.type2test([0, 1, 2, 3, 4])
@@ -199,9 +199,9 @@
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__)
@@ -213,8 +213,8 @@
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
@@ -227,7 +227,7 @@
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)
@@ -268,7 +268,7 @@
pass
u3 = subclass([0, 1])
self.assertEqual(u3, u3*1)
- self.assert_(u3 is not u3*1)
+ self.assertIsNot(u3, u3*1)
def test_iadd(self):
u = self.type2test([0, 1])
diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 5f5b291..a813616 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -67,7 +67,7 @@
else:
obj = subtype(obj)
realresult = getattr(obj, methodname)(*args)
- self.assert_(obj is not realresult)
+ self.assertIsNot(obj, realresult)
# check that obj.method(*args) raises exc
def checkraises(self, exc, obj, methodname, *args):
@@ -1170,34 +1170,34 @@
pass
s1 = subclass("abcd")
s2 = t().join([s1])
- self.assert_(s1 is not s2)
- self.assert_(type(s2) is t)
+ self.assertIsNot(s1, s2)
+ self.assertIs(type(s2), t)
s1 = t("abcd")
s2 = t().join([s1])
- self.assert_(s1 is s2)
+ self.assertIs(s1, s2)
# Should also test mixed-type join.
if t is str:
s1 = subclass("abcd")
s2 = "".join([s1])
- self.assert_(s1 is not s2)
- self.assert_(type(s2) is t)
+ self.assertIsNot(s1, s2)
+ self.assertIs(type(s2), t)
s1 = t("abcd")
s2 = "".join([s1])
- self.assert_(s1 is s2)
+ self.assertIs(s1, s2)
## elif t is str8:
## s1 = subclass("abcd")
## s2 = "".join([s1])
-## self.assert_(s1 is not s2)
-## self.assert_(type(s2) is str) # promotes!
+## self.assertIsNot(s1, s2)
+## self.assertIs(type(s2), str) # promotes!
## s1 = t("abcd")
## s2 = "".join([s1])
-## self.assert_(s1 is not s2)
-## self.assert_(type(s2) is str) # promotes!
+## self.assertIsNot(s1, s2)
+## self.assertIs(type(s2), str) # promotes!
else:
self.fail("unexpected type for MixinStrUnicodeTest %r" % t)
diff --git a/Lib/test/test_SimpleHTTPServer.py b/Lib/test/test_SimpleHTTPServer.py
index 36c2b89..bca9bd6 100644
--- a/Lib/test/test_SimpleHTTPServer.py
+++ b/Lib/test/test_SimpleHTTPServer.py
@@ -21,17 +21,17 @@
def test_queryArguments (self):
path = self.handler.translate_path ('/filename')
- self.assertEquals (path, self.translated)
+ self.assertEqual (path, self.translated)
path = self.handler.translate_path ('/filename?foo=bar')
- self.assertEquals (path, self.translated)
+ self.assertEqual (path, self.translated)
path = self.handler.translate_path ('/filename?a=b&spam=eggs#zot')
- self.assertEquals (path, self.translated)
+ self.assertEqual (path, self.translated)
def test_startWithDoubleSlash (self):
path = self.handler.translate_path ('//filename')
- self.assertEquals (path, self.translated)
+ self.assertEqual (path, self.translated)
path = self.handler.translate_path ('//filename?foo=bar')
- self.assertEquals (path, self.translated)
+ self.assertEqual (path, self.translated)
def test_main():
diff --git a/Lib/test/test__locale.py b/Lib/test/test__locale.py
index 54ac6aa..02942d1 100644
--- a/Lib/test/test__locale.py
+++ b/Lib/test/test__locale.py
@@ -59,7 +59,7 @@
known_value = known_numerics.get(used_locale,
('', ''))[data_type == 'thousands_sep']
if known_value and calc_value:
- self.assertEquals(calc_value, known_value,
+ self.assertEqual(calc_value, known_value,
self.lc_numeric_err_msg % (
calc_value, known_value,
calc_type, data_type, set_locale,
@@ -107,7 +107,7 @@
set_locale = setlocale(LC_NUMERIC)
except Error:
set_locale = "<not able to determine>"
- self.assertEquals(nl_radixchar, li_radixchar,
+ self.assertEqual(nl_radixchar, li_radixchar,
"%s (nl_langinfo) != %s (localeconv) "
"(set to %s, using %s)" % (
nl_radixchar, li_radixchar,
@@ -127,9 +127,9 @@
if loc == 'eu_ES' and localeconv()['decimal_point'] == "' ":
continue
- self.assertEquals(int(eval('3.14') * 100), 314,
+ self.assertEqual(int(eval('3.14') * 100), 314,
"using eval('3.14') failed for %s" % loc)
- self.assertEquals(int(float('3.14') * 100), 314,
+ self.assertEqual(int(float('3.14') * 100), 314,
"using float('3.14') failed for %s" % loc)
if localeconv()['decimal_point'] != '.':
self.assertRaises(ValueError, float,
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 4cac68b..97cec11 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -601,11 +601,11 @@
data.reverse()
L[start:stop:step] = data
a[start:stop:step] = array.array(self.typecode, data)
- self.assertEquals(a, array.array(self.typecode, L))
+ self.assertEqual(a, array.array(self.typecode, L))
del L[start:stop:step]
del a[start:stop:step]
- self.assertEquals(a, array.array(self.typecode, L))
+ self.assertEqual(a, array.array(self.typecode, L))
def test_index(self):
example = 2*self.example
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
index 01c4ba3..c74a30d 100644
--- a/Lib/test/test_ast.py
+++ b/Lib/test/test_ast.py
@@ -137,7 +137,7 @@
(eval_tests, eval_results, "eval")):
for i, o in zip(input, output):
ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
- self.assertEquals(to_tuple(ast_tree), o)
+ self.assertEqual(to_tuple(ast_tree), o)
self._assertTrueorder(ast_tree, (0, 0))
def test_base_classes(self):
@@ -150,20 +150,20 @@
def test_nodeclasses(self):
x = ast.BinOp(1, 2, 3, lineno=0)
- self.assertEquals(x.left, 1)
- self.assertEquals(x.op, 2)
- self.assertEquals(x.right, 3)
- self.assertEquals(x.lineno, 0)
+ self.assertEqual(x.left, 1)
+ self.assertEqual(x.op, 2)
+ self.assertEqual(x.right, 3)
+ self.assertEqual(x.lineno, 0)
# node raises exception when not given enough arguments
self.assertRaises(TypeError, ast.BinOp, 1, 2)
# can set attributes through kwargs too
x = ast.BinOp(left=1, op=2, right=3, lineno=0)
- self.assertEquals(x.left, 1)
- self.assertEquals(x.op, 2)
- self.assertEquals(x.right, 3)
- self.assertEquals(x.lineno, 0)
+ self.assertEqual(x.left, 1)
+ self.assertEqual(x.op, 2)
+ self.assertEqual(x.right, 3)
+ self.assertEqual(x.lineno, 0)
# this used to fail because Sub._fields was None
x = ast.Sub()
@@ -181,7 +181,7 @@
for protocol in protocols:
for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests):
ast2 = mod.loads(mod.dumps(ast, protocol))
- self.assertEquals(to_tuple(ast2), to_tuple(ast))
+ self.assertEqual(to_tuple(ast2), to_tuple(ast))
def test_invalid_sum(self):
pos = dict(lineno=2, col_offset=3)
diff --git a/Lib/test/test_asyncore.py b/Lib/test/test_asyncore.py
index c82f9b7..fc1d166 100644
--- a/Lib/test/test_asyncore.py
+++ b/Lib/test/test_asyncore.py
@@ -254,7 +254,7 @@
sys.stderr = stderr
lines = fp.getvalue().splitlines()
- self.assertEquals(lines, ['log: %s' % l1, 'log: %s' % l2])
+ self.assertEqual(lines, ['log: %s' % l1, 'log: %s' % l2])
def test_log_info(self):
d = asyncore.dispatcher()
@@ -276,7 +276,7 @@
lines = fp.getvalue().splitlines()
expected = ['EGGS: %s' % l1, 'info: %s' % l2, 'SPAM: %s' % l3]
- self.assertEquals(lines, expected)
+ self.assertEqual(lines, expected)
def test_unhandled(self):
d = asyncore.dispatcher()
@@ -301,7 +301,7 @@
'warning: unhandled write event',
'warning: unhandled connect event',
'warning: unhandled accept event']
- self.assertEquals(lines, expected)
+ self.assertEqual(lines, expected)
def test_issue_8594(self):
d = asyncore.dispatcher(socket.socket())
diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py
index e1b6e27..6126667 100644
--- a/Lib/test/test_augassign.py
+++ b/Lib/test/test_augassign.py
@@ -17,7 +17,7 @@
x |= 5
x ^= 1
x /= 2
- self.assertEquals(x, 3.0)
+ self.assertEqual(x, 3.0)
def test_with_unpacking(self):
self.assertRaises(SyntaxError, compile, "x, b += 3", "<test>", "exec")
@@ -34,7 +34,7 @@
x[0] |= 5
x[0] ^= 1
x[0] /= 2
- self.assertEquals(x[0], 3.0)
+ self.assertEqual(x[0], 3.0)
def testInDict(self):
x = {0: 2}
@@ -48,21 +48,21 @@
x[0] |= 5
x[0] ^= 1
x[0] /= 2
- self.assertEquals(x[0], 3.0)
+ self.assertEqual(x[0], 3.0)
def testSequences(self):
x = [1,2]
x += [3,4]
x *= 2
- self.assertEquals(x, [1, 2, 3, 4, 1, 2, 3, 4])
+ self.assertEqual(x, [1, 2, 3, 4, 1, 2, 3, 4])
x = [1, 2, 3]
y = x
x[1:2] *= 2
y[1:2] += [1]
- self.assertEquals(x, [1, 2, 1, 2, 3])
+ self.assertEqual(x, [1, 2, 1, 2, 3])
self.assertTrue(x is y)
def testCustomMethods1(self):
@@ -90,14 +90,14 @@
self.assertTrue(isinstance(x, aug_test))
self.assertTrue(y is not x)
- self.assertEquals(x.val, 11)
+ self.assertEqual(x.val, 11)
x = aug_test2(2)
y = x
x += 10
self.assertTrue(y is x)
- self.assertEquals(x.val, 12)
+ self.assertEqual(x.val, 12)
x = aug_test3(3)
y = x
@@ -105,7 +105,7 @@
self.assertTrue(isinstance(x, aug_test3))
self.assertTrue(y is not x)
- self.assertEquals(x.val, 13)
+ self.assertEqual(x.val, 13)
def testCustomMethods2(test_self):
@@ -269,7 +269,7 @@
1 << x
x <<= 1
- test_self.assertEquals(output, '''\
+ test_self.assertEqual(output, '''\
__add__ called
__radd__ called
__iadd__ called
diff --git a/Lib/test/test_base64.py b/Lib/test/test_base64.py
index 49edf39..33aacd6 100644
--- a/Lib/test/test_base64.py
+++ b/Lib/test/test_base64.py
@@ -6,7 +6,7 @@
import subprocess
-
+
class LegacyBase64TestCase(unittest.TestCase):
def test_encodebytes(self):
eq = self.assertEqual
@@ -58,7 +58,7 @@
base64.decode(infp, outfp)
self.assertEqual(outfp.getvalue(), b'www.python.org')
-
+
class BaseXYTestCase(unittest.TestCase):
def test_b64encode(self):
eq = self.assertEqual
@@ -209,7 +209,7 @@
self.assertTrue(issubclass(binascii.Error, ValueError))
-
+
class TestMain(unittest.TestCase):
def get_output(self, *args, **options):
args = (sys.executable, '-m', 'base64') + args
@@ -228,20 +228,20 @@
fp.write(b'a\xffb\n')
output = self.get_output('-e', support.TESTFN)
- self.assertEquals(output.rstrip(), b'Yf9iCg==')
+ self.assertEqual(output.rstrip(), b'Yf9iCg==')
with open(support.TESTFN, 'rb') as fp:
output = self.get_output('-e', stdin=fp)
- self.assertEquals(output.rstrip(), b'Yf9iCg==')
+ self.assertEqual(output.rstrip(), b'Yf9iCg==')
def test_decode(self):
with open(support.TESTFN, 'wb') as fp:
fp.write(b'Yf9iCg==')
output = self.get_output('-d', support.TESTFN)
- self.assertEquals(output.rstrip(), b'a\xffb')
+ self.assertEqual(output.rstrip(), b'a\xffb')
-
+
def test_main():
support.run_unittest(__name__)
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py
index 030ada5..7def22b 100644
--- a/Lib/test/test_bigmem.py
+++ b/Lib/test/test_bigmem.py
@@ -13,7 +13,7 @@
# doesn't release the old 's' (if it exists) until well after its new
# value has been created. Use 'del s' before the create_largestring call.
#
-# - Do *not* compare large objects using assertEquals or similar. It's a
+# - Do *not* compare large objects using assertEqual or similar. It's a
# lengthy operation and the errormessage will be utterly useless due to
# its size. To make sure whether a result has the right contents, better
# to use the strip or count methods, or compare meaningful slices.
@@ -48,32 +48,32 @@
SUBSTR = self.from_latin1(' abc def ghi')
s = _('-') * size + SUBSTR
caps = s.capitalize()
- self.assertEquals(caps[-len(SUBSTR):],
+ self.assertEqual(caps[-len(SUBSTR):],
SUBSTR.capitalize())
- self.assertEquals(caps.lstrip(_('-')), SUBSTR)
+ self.assertEqual(caps.lstrip(_('-')), SUBSTR)
@bigmemtest(minsize=_2G + 10, memuse=1)
def test_center(self, size):
SUBSTR = self.from_latin1(' abc def ghi')
s = SUBSTR.center(size)
- self.assertEquals(len(s), size)
+ self.assertEqual(len(s), size)
lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2
if len(s) % 2:
lpadsize += 1
- self.assertEquals(s[lpadsize:-rpadsize], SUBSTR)
- self.assertEquals(s.strip(), SUBSTR.strip())
+ self.assertEqual(s[lpadsize:-rpadsize], SUBSTR)
+ self.assertEqual(s.strip(), SUBSTR.strip())
@bigmemtest(minsize=_2G, memuse=2)
def test_count(self, size):
_ = self.from_latin1
SUBSTR = _(' abc def ghi')
s = _('.') * size + SUBSTR
- self.assertEquals(s.count(_('.')), size)
+ self.assertEqual(s.count(_('.')), size)
s += _('.')
- self.assertEquals(s.count(_('.')), size + 1)
- self.assertEquals(s.count(_(' ')), 3)
- self.assertEquals(s.count(_('i')), 1)
- self.assertEquals(s.count(_('j')), 0)
+ self.assertEqual(s.count(_('.')), size + 1)
+ self.assertEqual(s.count(_(' ')), 3)
+ self.assertEqual(s.count(_('i')), 1)
+ self.assertEqual(s.count(_('j')), 0)
@bigmemtest(minsize=_2G, memuse=2)
def test_endswith(self, size):
@@ -92,13 +92,13 @@
_ = self.from_latin1
s = _('-') * size
tabsize = 8
- self.assertEquals(s.expandtabs(), s)
+ self.assertEqual(s.expandtabs(), s)
del s
slen, remainder = divmod(size, tabsize)
s = _(' \t') * slen
s = s.expandtabs(tabsize)
- self.assertEquals(len(s), size - remainder)
- self.assertEquals(len(s.strip(_(' '))), 0)
+ self.assertEqual(len(s), size - remainder)
+ self.assertEqual(len(s.strip(_(' '))), 0)
@bigmemtest(minsize=_2G, memuse=2)
def test_find(self, size):
@@ -106,16 +106,16 @@
SUBSTR = _(' abc def ghi')
sublen = len(SUBSTR)
s = _('').join([SUBSTR, _('-') * size, SUBSTR])
- self.assertEquals(s.find(_(' ')), 0)
- self.assertEquals(s.find(SUBSTR), 0)
- self.assertEquals(s.find(_(' '), sublen), sublen + size)
- self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size)
- self.assertEquals(s.find(_('i')), SUBSTR.find(_('i')))
- self.assertEquals(s.find(_('i'), sublen),
+ self.assertEqual(s.find(_(' ')), 0)
+ self.assertEqual(s.find(SUBSTR), 0)
+ self.assertEqual(s.find(_(' '), sublen), sublen + size)
+ self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size)
+ self.assertEqual(s.find(_('i')), SUBSTR.find(_('i')))
+ self.assertEqual(s.find(_('i'), sublen),
sublen + size + SUBSTR.find(_('i')))
- self.assertEquals(s.find(_('i'), size),
+ self.assertEqual(s.find(_('i'), size),
sublen + size + SUBSTR.find(_('i')))
- self.assertEquals(s.find(_('j')), -1)
+ self.assertEqual(s.find(_('j')), -1)
@bigmemtest(minsize=_2G, memuse=2)
def test_index(self, size):
@@ -123,14 +123,14 @@
SUBSTR = _(' abc def ghi')
sublen = len(SUBSTR)
s = _('').join([SUBSTR, _('-') * size, SUBSTR])
- self.assertEquals(s.index(_(' ')), 0)
- self.assertEquals(s.index(SUBSTR), 0)
- self.assertEquals(s.index(_(' '), sublen), sublen + size)
- self.assertEquals(s.index(SUBSTR, sublen), sublen + size)
- self.assertEquals(s.index(_('i')), SUBSTR.index(_('i')))
- self.assertEquals(s.index(_('i'), sublen),
+ self.assertEqual(s.index(_(' ')), 0)
+ self.assertEqual(s.index(SUBSTR), 0)
+ self.assertEqual(s.index(_(' '), sublen), sublen + size)
+ self.assertEqual(s.index(SUBSTR, sublen), sublen + size)
+ self.assertEqual(s.index(_('i')), SUBSTR.index(_('i')))
+ self.assertEqual(s.index(_('i'), sublen),
sublen + size + SUBSTR.index(_('i')))
- self.assertEquals(s.index(_('i'), size),
+ self.assertEqual(s.index(_('i'), size),
sublen + size + SUBSTR.index(_('i')))
self.assertRaises(ValueError, s.index, _('j'))
@@ -209,8 +209,8 @@
_ = self.from_latin1
s = _('A') * size
x = s.join([_('aaaaa'), _('bbbbb')])
- self.assertEquals(x.count(_('a')), 5)
- self.assertEquals(x.count(_('b')), 5)
+ self.assertEqual(x.count(_('a')), 5)
+ self.assertEqual(x.count(_('b')), 5)
self.assertTrue(x.startswith(_('aaaaaA')))
self.assertTrue(x.endswith(_('Abbbbb')))
@@ -220,27 +220,27 @@
SUBSTR = _(' abc def ghi')
s = SUBSTR.ljust(size)
self.assertTrue(s.startswith(SUBSTR + _(' ')))
- self.assertEquals(len(s), size)
- self.assertEquals(s.strip(), SUBSTR.strip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.strip(), SUBSTR.strip())
@bigmemtest(minsize=_2G + 10, memuse=2)
def test_lower(self, size):
_ = self.from_latin1
s = _('A') * size
s = s.lower()
- self.assertEquals(len(s), size)
- self.assertEquals(s.count(_('a')), size)
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.count(_('a')), size)
@bigmemtest(minsize=_2G + 10, memuse=1)
def test_lstrip(self, size):
_ = self.from_latin1
SUBSTR = _('abc def ghi')
s = SUBSTR.rjust(size)
- self.assertEquals(len(s), size)
- self.assertEquals(s.lstrip(), SUBSTR.lstrip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.lstrip(), SUBSTR.lstrip())
del s
s = SUBSTR.ljust(size)
- self.assertEquals(len(s), size)
+ self.assertEqual(len(s), size)
# Type-specific optimization
if isinstance(s, (str, bytes)):
stripped = s.lstrip()
@@ -252,12 +252,12 @@
replacement = _('a')
s = _(' ') * size
s = s.replace(_(' '), replacement)
- self.assertEquals(len(s), size)
- self.assertEquals(s.count(replacement), size)
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.count(replacement), size)
s = s.replace(replacement, _(' '), size - 4)
- self.assertEquals(len(s), size)
- self.assertEquals(s.count(replacement), 4)
- self.assertEquals(s[-10:], _(' aaaa'))
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.count(replacement), 4)
+ self.assertEqual(s[-10:], _(' aaaa'))
@bigmemtest(minsize=_2G, memuse=2)
def test_rfind(self, size):
@@ -265,15 +265,15 @@
SUBSTR = _(' abc def ghi')
sublen = len(SUBSTR)
s = _('').join([SUBSTR, _('-') * size, SUBSTR])
- self.assertEquals(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' ')))
- self.assertEquals(s.rfind(SUBSTR), sublen + size)
- self.assertEquals(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' ')))
- self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0)
- self.assertEquals(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i')))
- self.assertEquals(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i')))
- self.assertEquals(s.rfind(_('i'), 0, sublen + size),
- SUBSTR.rfind(_('i')))
- self.assertEquals(s.rfind(_('j')), -1)
+ self.assertEqual(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' ')))
+ self.assertEqual(s.rfind(SUBSTR), sublen + size)
+ self.assertEqual(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' ')))
+ self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0)
+ self.assertEqual(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i')))
+ self.assertEqual(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i')))
+ self.assertEqual(s.rfind(_('i'), 0, sublen + size),
+ SUBSTR.rfind(_('i')))
+ self.assertEqual(s.rfind(_('j')), -1)
@bigmemtest(minsize=_2G, memuse=2)
def test_rindex(self, size):
@@ -281,17 +281,17 @@
SUBSTR = _(' abc def ghi')
sublen = len(SUBSTR)
s = _('').join([SUBSTR, _('-') * size, SUBSTR])
- self.assertEquals(s.rindex(_(' ')),
- sublen + size + SUBSTR.rindex(_(' ')))
- self.assertEquals(s.rindex(SUBSTR), sublen + size)
- self.assertEquals(s.rindex(_(' '), 0, sublen + size - 1),
- SUBSTR.rindex(_(' ')))
- self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0)
- self.assertEquals(s.rindex(_('i')),
- sublen + size + SUBSTR.rindex(_('i')))
- self.assertEquals(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i')))
- self.assertEquals(s.rindex(_('i'), 0, sublen + size),
- SUBSTR.rindex(_('i')))
+ self.assertEqual(s.rindex(_(' ')),
+ sublen + size + SUBSTR.rindex(_(' ')))
+ self.assertEqual(s.rindex(SUBSTR), sublen + size)
+ self.assertEqual(s.rindex(_(' '), 0, sublen + size - 1),
+ SUBSTR.rindex(_(' ')))
+ self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0)
+ self.assertEqual(s.rindex(_('i')),
+ sublen + size + SUBSTR.rindex(_('i')))
+ self.assertEqual(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i')))
+ self.assertEqual(s.rindex(_('i'), 0, sublen + size),
+ SUBSTR.rindex(_('i')))
self.assertRaises(ValueError, s.rindex, _('j'))
@bigmemtest(minsize=_2G + 10, memuse=1)
@@ -300,19 +300,19 @@
SUBSTR = _(' abc def ghi')
s = SUBSTR.ljust(size)
self.assertTrue(s.startswith(SUBSTR + _(' ')))
- self.assertEquals(len(s), size)
- self.assertEquals(s.strip(), SUBSTR.strip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.strip(), SUBSTR.strip())
@bigmemtest(minsize=_2G + 10, memuse=1)
def test_rstrip(self, size):
_ = self.from_latin1
SUBSTR = _(' abc def ghi')
s = SUBSTR.ljust(size)
- self.assertEquals(len(s), size)
- self.assertEquals(s.rstrip(), SUBSTR.rstrip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.rstrip(), SUBSTR.rstrip())
del s
s = SUBSTR.rjust(size)
- self.assertEquals(len(s), size)
+ self.assertEqual(len(s), size)
# Type-specific optimization
if isinstance(s, (str, bytes)):
stripped = s.rstrip()
@@ -330,16 +330,16 @@
SUBSTR = _('a') + _(' ') * chunksize
s = SUBSTR * chunksize
l = s.split()
- self.assertEquals(len(l), chunksize)
+ self.assertEqual(len(l), chunksize)
expected = _('a')
for item in l:
- self.assertEquals(item, expected)
+ self.assertEqual(item, expected)
del l
l = s.split(_('a'))
- self.assertEquals(len(l), chunksize + 1)
+ self.assertEqual(len(l), chunksize + 1)
expected = _(' ') * chunksize
for item in filter(None, l):
- self.assertEquals(item, expected)
+ self.assertEqual(item, expected)
# Allocates a string of twice size (and briefly two) and a list of
# size. Because of internal affairs, the s.split() call produces a
@@ -352,12 +352,12 @@
_ = self.from_latin1
s = _(' a') * size + _(' ')
l = s.split()
- self.assertEquals(len(l), size)
- self.assertEquals(set(l), set([_('a')]))
+ self.assertEqual(len(l), size)
+ self.assertEqual(set(l), set([_('a')]))
del l
l = s.split(_('a'))
- self.assertEquals(len(l), size + 1)
- self.assertEquals(set(l), set([_(' ')]))
+ self.assertEqual(len(l), size + 1)
+ self.assertEqual(set(l), set([_(' ')]))
@bigmemtest(minsize=_2G, memuse=2.1)
def test_splitlines(self, size):
@@ -368,10 +368,10 @@
SUBSTR = _(' ') * chunksize + _('\n') + _(' ') * chunksize + _('\r\n')
s = SUBSTR * chunksize
l = s.splitlines()
- self.assertEquals(len(l), chunksize * 2)
+ self.assertEqual(len(l), chunksize * 2)
expected = _(' ') * chunksize
for item in l:
- self.assertEquals(item, expected)
+ self.assertEqual(item, expected)
@bigmemtest(minsize=_2G, memuse=2)
def test_startswith(self, size):
@@ -387,12 +387,12 @@
_ = self.from_latin1
SUBSTR = _(' abc def ghi ')
s = SUBSTR.rjust(size)
- self.assertEquals(len(s), size)
- self.assertEquals(s.strip(), SUBSTR.strip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.strip(), SUBSTR.strip())
del s
s = SUBSTR.ljust(size)
- self.assertEquals(len(s), size)
- self.assertEquals(s.strip(), SUBSTR.strip())
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.strip(), SUBSTR.strip())
@bigmemtest(minsize=_2G, memuse=2)
def test_swapcase(self, size):
@@ -402,9 +402,9 @@
repeats = size // sublen + 2
s = SUBSTR * repeats
s = s.swapcase()
- self.assertEquals(len(s), sublen * repeats)
- self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3)
- self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3)
+ self.assertEqual(len(s), sublen * repeats)
+ self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3)
+ self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3)
@bigmemtest(minsize=_2G, memuse=2)
def test_title(self, size):
@@ -431,20 +431,20 @@
repeats = size // sublen + 2
s = SUBSTR * repeats
s = s.translate(trans)
- self.assertEquals(len(s), repeats * sublen)
- self.assertEquals(s[:sublen], SUBSTR.translate(trans))
- self.assertEquals(s[-sublen:], SUBSTR.translate(trans))
- self.assertEquals(s.count(_('.')), 0)
- self.assertEquals(s.count(_('!')), repeats * 2)
- self.assertEquals(s.count(_('z')), repeats * 3)
+ self.assertEqual(len(s), repeats * sublen)
+ self.assertEqual(s[:sublen], SUBSTR.translate(trans))
+ self.assertEqual(s[-sublen:], SUBSTR.translate(trans))
+ self.assertEqual(s.count(_('.')), 0)
+ self.assertEqual(s.count(_('!')), repeats * 2)
+ self.assertEqual(s.count(_('z')), repeats * 3)
@bigmemtest(minsize=_2G + 5, memuse=2)
def test_upper(self, size):
_ = self.from_latin1
s = _('a') * size
s = s.upper()
- self.assertEquals(len(s), size)
- self.assertEquals(s.count(_('A')), size)
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.count(_('A')), size)
@bigmemtest(minsize=_2G + 20, memuse=1)
def test_zfill(self, size):
@@ -453,8 +453,8 @@
s = SUBSTR.zfill(size)
self.assertTrue(s.endswith(_('0') + SUBSTR[1:]))
self.assertTrue(s.startswith(_('-0')))
- self.assertEquals(len(s), size)
- self.assertEquals(s.count(_('0')), size - len(SUBSTR))
+ self.assertEqual(len(s), size)
+ self.assertEqual(s.count(_('0')), size - len(SUBSTR))
# This test is meaningful even with size < 2G, as long as the
# doubled string is > 2G (but it tests more if both are > 2G :)
@@ -462,10 +462,10 @@
def test_concat(self, size):
_ = self.from_latin1
s = _('.') * size
- self.assertEquals(len(s), size)
+ self.assertEqual(len(s), size)
s = s + s
- self.assertEquals(len(s), size * 2)
- self.assertEquals(s.count(_('.')), size * 2)
+ self.assertEqual(len(s), size * 2)
+ self.assertEqual(s.count(_('.')), size * 2)
# This test is meaningful even with size < 2G, as long as the
# repeated string is > 2G (but it tests more if both are > 2G :)
@@ -473,10 +473,10 @@
def test_repeat(self, size):
_ = self.from_latin1
s = _('.') * size
- self.assertEquals(len(s), size)
+ self.assertEqual(len(s), size)
s = s * 2
- self.assertEquals(len(s), size * 2)
- self.assertEquals(s.count(_('.')), size * 2)
+ self.assertEqual(len(s), size * 2)
+ self.assertEqual(s.count(_('.')), size * 2)
@bigmemtest(minsize=_2G + 20, memuse=2)
def test_slice_and_getitem(self, size):
@@ -487,26 +487,26 @@
stepsize = len(s) // 100
stepsize = stepsize - (stepsize % sublen)
for i in range(0, len(s) - stepsize, stepsize):
- self.assertEquals(s[i], SUBSTR[0])
- self.assertEquals(s[i:i + sublen], SUBSTR)
- self.assertEquals(s[i:i + sublen:2], SUBSTR[::2])
+ self.assertEqual(s[i], SUBSTR[0])
+ self.assertEqual(s[i:i + sublen], SUBSTR)
+ self.assertEqual(s[i:i + sublen:2], SUBSTR[::2])
if i > 0:
- self.assertEquals(s[i + sublen - 1:i - 1:-3],
- SUBSTR[sublen::-3])
+ self.assertEqual(s[i + sublen - 1:i - 1:-3],
+ SUBSTR[sublen::-3])
# Make sure we do some slicing and indexing near the end of the
# string, too.
- self.assertEquals(s[len(s) - 1], SUBSTR[-1])
- self.assertEquals(s[-1], SUBSTR[-1])
- self.assertEquals(s[len(s) - 10], SUBSTR[0])
- self.assertEquals(s[-sublen], SUBSTR[0])
- self.assertEquals(s[len(s):], _(''))
- self.assertEquals(s[len(s) - 1:], SUBSTR[-1:])
- self.assertEquals(s[-1:], SUBSTR[-1:])
- self.assertEquals(s[len(s) - sublen:], SUBSTR)
- self.assertEquals(s[-sublen:], SUBSTR)
- self.assertEquals(len(s[:]), len(s))
- self.assertEquals(len(s[:len(s) - 5]), len(s) - 5)
- self.assertEquals(len(s[5:-5]), len(s) - 10)
+ self.assertEqual(s[len(s) - 1], SUBSTR[-1])
+ self.assertEqual(s[-1], SUBSTR[-1])
+ self.assertEqual(s[len(s) - 10], SUBSTR[0])
+ self.assertEqual(s[-sublen], SUBSTR[0])
+ self.assertEqual(s[len(s):], _(''))
+ self.assertEqual(s[len(s) - 1:], SUBSTR[-1:])
+ self.assertEqual(s[-1:], SUBSTR[-1:])
+ self.assertEqual(s[len(s) - sublen:], SUBSTR)
+ self.assertEqual(s[-sublen:], SUBSTR)
+ self.assertEqual(len(s[:]), len(s))
+ self.assertEqual(len(s[:len(s) - 5]), len(s) - 5)
+ self.assertEqual(len(s[5:-5]), len(s) - 10)
self.assertRaises(IndexError, operator.getitem, s, len(s))
self.assertRaises(IndexError, operator.getitem, s, len(s) + 1)
@@ -565,7 +565,7 @@
expectedsize = size
s = c * size
- self.assertEquals(len(s.encode(enc)), expectedsize)
+ self.assertEqual(len(s.encode(enc)), expectedsize)
def setUp(self):
# HACK: adjust memory use of tests inherited from BaseStrTest
@@ -632,7 +632,7 @@
self.assertEqual(s, sf)
del sf
sf = '..%s..' % (s,)
- self.assertEquals(len(sf), len(s) + 4)
+ self.assertEqual(len(sf), len(s) + 4)
self.assertTrue(sf.startswith('..-'))
self.assertTrue(sf.endswith('-..'))
del s, sf
@@ -642,18 +642,18 @@
s = ''.join([edge, '%s', edge])
del edge
s = s % '...'
- self.assertEquals(len(s), size * 2 + 3)
- self.assertEquals(s.count('.'), 3)
- self.assertEquals(s.count('-'), size * 2)
+ self.assertEqual(len(s), size * 2 + 3)
+ self.assertEqual(s.count('.'), 3)
+ self.assertEqual(s.count('-'), size * 2)
@bigmemtest(minsize=_2G + 10, memuse=character_size * 2)
def test_repr_small(self, size):
s = '-' * size
s = repr(s)
- self.assertEquals(len(s), size + 2)
- self.assertEquals(s[0], "'")
- self.assertEquals(s[-1], "'")
- self.assertEquals(s.count('-'), size)
+ self.assertEqual(len(s), size + 2)
+ self.assertEqual(s[0], "'")
+ self.assertEqual(s[-1], "'")
+ self.assertEqual(s.count('-'), size)
del s
# repr() will create a string four times as large as this 'binary
# string', but we don't want to allocate much more than twice
@@ -661,21 +661,21 @@
size = size // 5 * 2
s = '\x00' * size
s = repr(s)
- self.assertEquals(len(s), size * 4 + 2)
- self.assertEquals(s[0], "'")
- self.assertEquals(s[-1], "'")
- self.assertEquals(s.count('\\'), size)
- self.assertEquals(s.count('0'), size * 2)
+ self.assertEqual(len(s), size * 4 + 2)
+ self.assertEqual(s[0], "'")
+ self.assertEqual(s[-1], "'")
+ self.assertEqual(s.count('\\'), size)
+ self.assertEqual(s.count('0'), size * 2)
@bigmemtest(minsize=_2G + 10, memuse=character_size * 5)
def test_repr_large(self, size):
s = '\x00' * size
s = repr(s)
- self.assertEquals(len(s), size * 4 + 2)
- self.assertEquals(s[0], "'")
- self.assertEquals(s[-1], "'")
- self.assertEquals(s.count('\\'), size)
- self.assertEquals(s.count('0'), size * 2)
+ self.assertEqual(len(s), size * 4 + 2)
+ self.assertEqual(s[0], "'")
+ self.assertEqual(s[-1], "'")
+ self.assertEqual(s.count('\\'), size)
+ self.assertEqual(s.count('0'), size * 2)
@bigmemtest(minsize=2**32 / 5, memuse=character_size * 7)
def test_unicode_repr(self, size):
@@ -706,7 +706,7 @@
@bigmemtest(minsize=_2G + 2, memuse=1 + character_size)
def test_decode(self, size):
s = self.from_latin1('.') * size
- self.assertEquals(len(s.decode('utf-8')), size)
+ self.assertEqual(len(s.decode('utf-8')), size)
class BytearrayTest(unittest.TestCase, BaseStrTest):
@@ -717,7 +717,7 @@
@bigmemtest(minsize=_2G + 2, memuse=1 + character_size)
def test_decode(self, size):
s = self.from_latin1('.') * size
- self.assertEquals(len(s.decode('utf-8')), size)
+ self.assertEqual(len(s.decode('utf-8')), size)
test_hash = None
test_split_large = None
@@ -752,9 +752,9 @@
# skipped, in verbose mode.)
def basic_concat_test(self, size):
t = ((),) * size
- self.assertEquals(len(t), size)
+ self.assertEqual(len(t), size)
t = t + t
- self.assertEquals(len(t), size * 2)
+ self.assertEqual(len(t), size * 2)
@bigmemtest(minsize=_2G // 2 + 2, memuse=24)
def test_concat_small(self, size):
@@ -767,7 +767,7 @@
@bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5)
def test_contains(self, size):
t = (1, 2, 3, 4, 5) * size
- self.assertEquals(len(t), size * 5)
+ self.assertEqual(len(t), size * 5)
self.assertTrue(5 in t)
self.assertFalse((1, 2, 3, 4, 5) in t)
self.assertFalse(0 in t)
@@ -783,27 +783,27 @@
@bigmemtest(minsize=_2G + 10, memuse=8)
def test_index_and_slice(self, size):
t = (None,) * size
- self.assertEquals(len(t), size)
- self.assertEquals(t[-1], None)
- self.assertEquals(t[5], None)
- self.assertEquals(t[size - 1], None)
+ self.assertEqual(len(t), size)
+ self.assertEqual(t[-1], None)
+ self.assertEqual(t[5], None)
+ self.assertEqual(t[size - 1], None)
self.assertRaises(IndexError, operator.getitem, t, size)
- self.assertEquals(t[:5], (None,) * 5)
- self.assertEquals(t[-5:], (None,) * 5)
- self.assertEquals(t[20:25], (None,) * 5)
- self.assertEquals(t[-25:-20], (None,) * 5)
- self.assertEquals(t[size - 5:], (None,) * 5)
- self.assertEquals(t[size - 5:size], (None,) * 5)
- self.assertEquals(t[size - 6:size - 2], (None,) * 4)
- self.assertEquals(t[size:size], ())
- self.assertEquals(t[size:size+5], ())
+ self.assertEqual(t[:5], (None,) * 5)
+ self.assertEqual(t[-5:], (None,) * 5)
+ self.assertEqual(t[20:25], (None,) * 5)
+ self.assertEqual(t[-25:-20], (None,) * 5)
+ self.assertEqual(t[size - 5:], (None,) * 5)
+ self.assertEqual(t[size - 5:size], (None,) * 5)
+ self.assertEqual(t[size - 6:size - 2], (None,) * 4)
+ self.assertEqual(t[size:size], ())
+ self.assertEqual(t[size:size+5], ())
# Like test_concat, split in two.
def basic_test_repeat(self, size):
t = ('',) * size
- self.assertEquals(len(t), size)
+ self.assertEqual(len(t), size)
t = t * 2
- self.assertEquals(len(t), size * 2)
+ self.assertEqual(len(t), size * 2)
@bigmemtest(minsize=_2G // 2 + 2, memuse=24)
def test_repeat_small(self, size):
@@ -826,9 +826,9 @@
else:
count = 0
for item in t:
- self.assertEquals(item, count)
+ self.assertEqual(item, count)
count += 1
- self.assertEquals(count, size)
+ self.assertEqual(count, size)
@precisionbigmemtest(size=_1G - 25, memuse=9)
def test_from_almost_2G_generator(self, size):
@@ -836,9 +836,9 @@
t = tuple(range(size))
count = 0
for item in t:
- self.assertEquals(item, count)
+ self.assertEqual(item, count)
count += 1
- self.assertEquals(count, size)
+ self.assertEqual(count, size)
except MemoryError:
pass # acceptable, expected on 32-bit
@@ -847,10 +847,10 @@
t = (0,) * size
s = repr(t)
# The repr of a tuple of 0's is exactly three times the tuple length.
- self.assertEquals(len(s), size * 3)
- self.assertEquals(s[:5], '(0, 0')
- self.assertEquals(s[-5:], '0, 0)')
- self.assertEquals(s.count('0'), size)
+ self.assertEqual(len(s), size * 3)
+ self.assertEqual(s[:5], '(0, 0')
+ self.assertEqual(s[-5:], '0, 0)')
+ self.assertEqual(s.count('0'), size)
@bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
def test_repr_small(self, size):
@@ -886,9 +886,9 @@
# skipped, in verbose mode.)
def basic_test_concat(self, size):
l = [[]] * size
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
l = l + l
- self.assertEquals(len(l), size * 2)
+ self.assertEqual(len(l), size * 2)
@bigmemtest(minsize=_2G // 2 + 2, memuse=24)
def test_concat_small(self, size):
@@ -901,7 +901,7 @@
def basic_test_inplace_concat(self, size):
l = [sys.stdout] * size
l += l
- self.assertEquals(len(l), size * 2)
+ self.assertEqual(len(l), size * 2)
self.assertTrue(l[0] is l[-1])
self.assertTrue(l[size - 1] is l[size + 1])
@@ -916,7 +916,7 @@
@bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5)
def test_contains(self, size):
l = [1, 2, 3, 4, 5] * size
- self.assertEquals(len(l), size * 5)
+ self.assertEqual(len(l), size * 5)
self.assertTrue(5 in l)
self.assertFalse([1, 2, 3, 4, 5] in l)
self.assertFalse(0 in l)
@@ -929,66 +929,66 @@
@bigmemtest(minsize=_2G + 10, memuse=8)
def test_index_and_slice(self, size):
l = [None] * size
- self.assertEquals(len(l), size)
- self.assertEquals(l[-1], None)
- self.assertEquals(l[5], None)
- self.assertEquals(l[size - 1], None)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-1], None)
+ self.assertEqual(l[5], None)
+ self.assertEqual(l[size - 1], None)
self.assertRaises(IndexError, operator.getitem, l, size)
- self.assertEquals(l[:5], [None] * 5)
- self.assertEquals(l[-5:], [None] * 5)
- self.assertEquals(l[20:25], [None] * 5)
- self.assertEquals(l[-25:-20], [None] * 5)
- self.assertEquals(l[size - 5:], [None] * 5)
- self.assertEquals(l[size - 5:size], [None] * 5)
- self.assertEquals(l[size - 6:size - 2], [None] * 4)
- self.assertEquals(l[size:size], [])
- self.assertEquals(l[size:size+5], [])
+ self.assertEqual(l[:5], [None] * 5)
+ self.assertEqual(l[-5:], [None] * 5)
+ self.assertEqual(l[20:25], [None] * 5)
+ self.assertEqual(l[-25:-20], [None] * 5)
+ self.assertEqual(l[size - 5:], [None] * 5)
+ self.assertEqual(l[size - 5:size], [None] * 5)
+ self.assertEqual(l[size - 6:size - 2], [None] * 4)
+ self.assertEqual(l[size:size], [])
+ self.assertEqual(l[size:size+5], [])
l[size - 2] = 5
- self.assertEquals(len(l), size)
- self.assertEquals(l[-3:], [None, 5, None])
- self.assertEquals(l.count(5), 1)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-3:], [None, 5, None])
+ self.assertEqual(l.count(5), 1)
self.assertRaises(IndexError, operator.setitem, l, size, 6)
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
l[size - 7:] = [1, 2, 3, 4, 5]
size -= 2
- self.assertEquals(len(l), size)
- self.assertEquals(l[-7:], [None, None, 1, 2, 3, 4, 5])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-7:], [None, None, 1, 2, 3, 4, 5])
l[:7] = [1, 2, 3, 4, 5]
size -= 2
- self.assertEquals(len(l), size)
- self.assertEquals(l[:7], [1, 2, 3, 4, 5, None, None])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[:7], [1, 2, 3, 4, 5, None, None])
del l[size - 1]
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[-1], 4)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-1], 4)
del l[-2:]
size -= 2
- self.assertEquals(len(l), size)
- self.assertEquals(l[-1], 2)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-1], 2)
del l[0]
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[0], 2)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[0], 2)
del l[:2]
size -= 2
- self.assertEquals(len(l), size)
- self.assertEquals(l[0], 4)
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[0], 4)
# Like test_concat, split in two.
def basic_test_repeat(self, size):
l = [] * size
self.assertFalse(l)
l = [''] * size
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
l = l * 2
- self.assertEquals(len(l), size * 2)
+ self.assertEqual(len(l), size * 2)
@bigmemtest(minsize=_2G // 2 + 2, memuse=24)
def test_repeat_small(self, size):
@@ -1001,13 +1001,13 @@
def basic_test_inplace_repeat(self, size):
l = ['']
l *= size
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
self.assertTrue(l[0] is l[-1])
del l
l = [''] * size
l *= 2
- self.assertEquals(len(l), size * 2)
+ self.assertEqual(len(l), size * 2)
self.assertTrue(l[size - 1] is l[-1])
@bigmemtest(minsize=_2G // 2 + 2, memuse=16)
@@ -1022,10 +1022,10 @@
l = [0] * size
s = repr(l)
# The repr of a list of 0's is exactly three times the list length.
- self.assertEquals(len(s), size * 3)
- self.assertEquals(s[:5], '[0, 0')
- self.assertEquals(s[-5:], '0, 0]')
- self.assertEquals(s.count('0'), size)
+ self.assertEqual(len(s), size * 3)
+ self.assertEqual(s[:5], '[0, 0')
+ self.assertEqual(s[-5:], '0, 0]')
+ self.assertEqual(s.count('0'), size)
@bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
def test_repr_small(self, size):
@@ -1041,20 +1041,20 @@
def test_append(self, size):
l = [object()] * size
l.append(object())
- self.assertEquals(len(l), size+1)
+ self.assertEqual(len(l), size+1)
self.assertTrue(l[-3] is l[-2])
self.assertFalse(l[-2] is l[-1])
@bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
def test_count(self, size):
l = [1, 2, 3, 4, 5] * size
- self.assertEquals(l.count(1), size)
- self.assertEquals(l.count("1"), 0)
+ self.assertEqual(l.count(1), size)
+ self.assertEqual(l.count("1"), 0)
def basic_test_extend(self, size):
l = [object] * size
l.extend(l)
- self.assertEquals(len(l), size * 2)
+ self.assertEqual(len(l), size * 2)
self.assertTrue(l[0] is l[-1])
self.assertTrue(l[size - 1] is l[size + 1])
@@ -1070,9 +1070,9 @@
def test_index(self, size):
l = [1, 2, 3, 4, 5] * size
size *= 5
- self.assertEquals(l.index(1), 0)
- self.assertEquals(l.index(5, size - 5), size - 1)
- self.assertEquals(l.index(5, size - 5, size), size - 1)
+ self.assertEqual(l.index(1), 0)
+ self.assertEqual(l.index(5, size - 5), size - 1)
+ self.assertEqual(l.index(5, size - 5, size), size - 1)
self.assertRaises(ValueError, l.index, 1, size - 4, size)
self.assertRaises(ValueError, l.index, 6)
@@ -1082,80 +1082,80 @@
l = [1.0] * size
l.insert(size - 1, "A")
size += 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[-3:], [1.0, "A", 1.0])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-3:], [1.0, "A", 1.0])
l.insert(size + 1, "B")
size += 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[-3:], ["A", 1.0, "B"])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-3:], ["A", 1.0, "B"])
l.insert(1, "C")
size += 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[:3], [1.0, "C", 1.0])
- self.assertEquals(l[size - 3:], ["A", 1.0, "B"])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[:3], [1.0, "C", 1.0])
+ self.assertEqual(l[size - 3:], ["A", 1.0, "B"])
@bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5)
def test_pop(self, size):
l = ["a", "b", "c", "d", "e"] * size
size *= 5
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
item = l.pop()
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(item, "e")
- self.assertEquals(l[-2:], ["c", "d"])
+ self.assertEqual(len(l), size)
+ self.assertEqual(item, "e")
+ self.assertEqual(l[-2:], ["c", "d"])
item = l.pop(0)
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(item, "a")
- self.assertEquals(l[:2], ["b", "c"])
+ self.assertEqual(len(l), size)
+ self.assertEqual(item, "a")
+ self.assertEqual(l[:2], ["b", "c"])
item = l.pop(size - 2)
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(item, "c")
- self.assertEquals(l[-2:], ["b", "d"])
+ self.assertEqual(len(l), size)
+ self.assertEqual(item, "c")
+ self.assertEqual(l[-2:], ["b", "d"])
@bigmemtest(minsize=_2G + 10, memuse=8)
def test_remove(self, size):
l = [10] * size
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
l.remove(10)
size -= 1
- self.assertEquals(len(l), size)
+ self.assertEqual(len(l), size)
# Because of the earlier l.remove(), this append doesn't trigger
# a resize.
l.append(5)
size += 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[-2:], [10, 5])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-2:], [10, 5])
l.remove(5)
size -= 1
- self.assertEquals(len(l), size)
- self.assertEquals(l[-2:], [10, 10])
+ self.assertEqual(len(l), size)
+ self.assertEqual(l[-2:], [10, 10])
@bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
def test_reverse(self, size):
l = [1, 2, 3, 4, 5] * size
l.reverse()
- self.assertEquals(len(l), size * 5)
- self.assertEquals(l[-5:], [5, 4, 3, 2, 1])
- self.assertEquals(l[:5], [5, 4, 3, 2, 1])
+ self.assertEqual(len(l), size * 5)
+ self.assertEqual(l[-5:], [5, 4, 3, 2, 1])
+ self.assertEqual(l[:5], [5, 4, 3, 2, 1])
@bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
def test_sort(self, size):
l = [1, 2, 3, 4, 5] * size
l.sort()
- self.assertEquals(len(l), size * 5)
- self.assertEquals(l.count(1), size)
- self.assertEquals(l[:10], [1] * 10)
- self.assertEquals(l[-10:], [5] * 10)
+ self.assertEqual(len(l), size * 5)
+ self.assertEqual(l.count(1), size)
+ self.assertEqual(l[:10], [1] * 10)
+ self.assertEqual(l[-10:], [5] * 10)
def test_main():
support.run_unittest(StrTest, BytesTest, BytearrayTest,
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 645ef9d..420a17f 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -551,15 +551,15 @@
class X:
def __hash__(self):
return 2**100
- self.assertEquals(type(hash(X())), int)
+ self.assertEqual(type(hash(X())), int)
class Y(object):
def __hash__(self):
return 2**100
- self.assertEquals(type(hash(Y())), int)
+ self.assertEqual(type(hash(Y())), int)
class Z(int):
def __hash__(self):
return self
- self.assertEquals(hash(Z(42)), hash(42))
+ self.assertEqual(hash(Z(42)), hash(42))
def test_hex(self):
self.assertEqual(hex(16), '0x10')
@@ -791,7 +791,7 @@
self.assertEqual(next(it), 1)
self.assertRaises(StopIteration, next, it)
self.assertRaises(StopIteration, next, it)
- self.assertEquals(next(it, 42), 42)
+ self.assertEqual(next(it, 42), 42)
class Iter(object):
def __iter__(self):
@@ -800,7 +800,7 @@
raise StopIteration
it = iter(Iter())
- self.assertEquals(next(it, 42), 42)
+ self.assertEqual(next(it, 42), 42)
self.assertRaises(StopIteration, next, it)
def gen():
@@ -808,9 +808,9 @@
return
it = gen()
- self.assertEquals(next(it), 1)
+ self.assertEqual(next(it), 1)
self.assertRaises(StopIteration, next, it)
- self.assertEquals(next(it, 42), 42)
+ self.assertEqual(next(it, 42), 42)
def test_oct(self):
self.assertEqual(oct(100), '0o144')
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 28ae5ca..8b964ca 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -246,11 +246,11 @@
def test_fromhex(self):
self.assertRaises(TypeError, self.type2test.fromhex)
self.assertRaises(TypeError, self.type2test.fromhex, 1)
- self.assertEquals(self.type2test.fromhex(''), self.type2test())
+ self.assertEqual(self.type2test.fromhex(''), self.type2test())
b = bytearray([0x1a, 0x2b, 0x30])
- self.assertEquals(self.type2test.fromhex('1a2B30'), b)
- self.assertEquals(self.type2test.fromhex(' 1A 2B 30 '), b)
- self.assertEquals(self.type2test.fromhex('0000'), b'\0\0')
+ self.assertEqual(self.type2test.fromhex('1a2B30'), b)
+ self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b)
+ self.assertEqual(self.type2test.fromhex('0000'), b'\0\0')
self.assertRaises(TypeError, self.type2test.fromhex, b'1B')
self.assertRaises(ValueError, self.type2test.fromhex, 'a')
self.assertRaises(ValueError, self.type2test.fromhex, 'rt')
@@ -609,11 +609,11 @@
data.reverse()
L[start:stop:step] = data
b[start:stop:step] = data
- self.assertEquals(b, bytearray(L))
+ self.assertEqual(b, bytearray(L))
del L[start:stop:step]
del b[start:stop:step]
- self.assertEquals(b, bytearray(L))
+ self.assertEqual(b, bytearray(L))
def test_setslice_trap(self):
# This test verifies that we correctly handle assigning self
@@ -792,25 +792,25 @@
resize(10)
orig = b[:]
self.assertRaises(BufferError, resize, 11)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
self.assertRaises(BufferError, resize, 9)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
self.assertRaises(BufferError, resize, 0)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
# Other operations implying resize
self.assertRaises(BufferError, b.pop, 0)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
self.assertRaises(BufferError, b.remove, b[1])
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
def delitem():
del b[1]
self.assertRaises(BufferError, delitem)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
# deleting a non-contiguous slice
def delslice():
b[1:-1:2] = b""
self.assertRaises(BufferError, delslice)
- self.assertEquals(b, orig)
+ self.assertEqual(b, orig)
def test_empty_bytearray(self):
# Issue #7561: operations on empty bytearrays could crash in many
diff --git a/Lib/test/test_cfgparser.py b/Lib/test/test_cfgparser.py
index a3d2640..299870c 100644
--- a/Lib/test/test_cfgparser.py
+++ b/Lib/test/test_cfgparser.py
@@ -463,14 +463,14 @@
"k=v\n")
output = io.StringIO()
self.cf.write(output)
- self.assertEquals(output.getvalue(),
- "[a]\n"
- "k = v\n\n"
- "[b]\n"
- "o1 = 4\n"
- "o2 = 3\n"
- "o3 = 2\n"
- "o4 = 1\n\n")
+ self.assertEqual(output.getvalue(),
+ "[a]\n"
+ "k = v\n\n"
+ "[b]\n"
+ "o1 = 4\n"
+ "o2 = 3\n"
+ "o3 = 2\n"
+ "o4 = 1\n\n")
def test_main():
support.run_unittest(
diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py
index ef7dfa5..16c6204 100644
--- a/Lib/test/test_cgi.py
+++ b/Lib/test/test_cgi.py
@@ -220,7 +220,7 @@
-----------------------------721837373350705526688164684--
"""
fs = cgi.FieldStorage(fp=StringIO(postdata), environ=env)
- self.assertEquals(len(fs.list), 4)
+ self.assertEqual(len(fs.list), 4)
expect = [{'name':'id', 'filename':None, 'value':'1234'},
{'name':'title', 'filename':None, 'value':''},
{'name':'file', 'filename':'test.txt', 'value':'Testing 123.'},
@@ -228,7 +228,7 @@
for x in range(len(fs.list)):
for k, exp in expect[x].items():
got = getattr(fs.list[x], k)
- self.assertEquals(got, exp)
+ self.assertEqual(got, exp)
_qs_result = {
'key1': 'value1',
diff --git a/Lib/test/test_charmapcodec.py b/Lib/test/test_charmapcodec.py
index 8b79bde..6226587 100644
--- a/Lib/test/test_charmapcodec.py
+++ b/Lib/test/test_charmapcodec.py
@@ -27,24 +27,24 @@
class CharmapCodecTest(unittest.TestCase):
def test_constructorx(self):
- self.assertEquals(str(b'abc', codecname), 'abc')
- self.assertEquals(str(b'xdef', codecname), 'abcdef')
- self.assertEquals(str(b'defx', codecname), 'defabc')
- self.assertEquals(str(b'dxf', codecname), 'dabcf')
- self.assertEquals(str(b'dxfx', codecname), 'dabcfabc')
+ self.assertEqual(str(b'abc', codecname), 'abc')
+ self.assertEqual(str(b'xdef', codecname), 'abcdef')
+ self.assertEqual(str(b'defx', codecname), 'defabc')
+ self.assertEqual(str(b'dxf', codecname), 'dabcf')
+ self.assertEqual(str(b'dxfx', codecname), 'dabcfabc')
def test_encodex(self):
- self.assertEquals('abc'.encode(codecname), b'abc')
- self.assertEquals('xdef'.encode(codecname), b'abcdef')
- self.assertEquals('defx'.encode(codecname), b'defabc')
- self.assertEquals('dxf'.encode(codecname), b'dabcf')
- self.assertEquals('dxfx'.encode(codecname), b'dabcfabc')
+ self.assertEqual('abc'.encode(codecname), b'abc')
+ self.assertEqual('xdef'.encode(codecname), b'abcdef')
+ self.assertEqual('defx'.encode(codecname), b'defabc')
+ self.assertEqual('dxf'.encode(codecname), b'dabcf')
+ self.assertEqual('dxfx'.encode(codecname), b'dabcfabc')
def test_constructory(self):
- self.assertEquals(str(b'ydef', codecname), 'def')
- self.assertEquals(str(b'defy', codecname), 'def')
- self.assertEquals(str(b'dyf', codecname), 'df')
- self.assertEquals(str(b'dyfy', codecname), 'df')
+ self.assertEqual(str(b'ydef', codecname), 'def')
+ self.assertEqual(str(b'defy', codecname), 'def')
+ self.assertEqual(str(b'dyf', codecname), 'df')
+ self.assertEqual(str(b'dyfy', codecname), 'df')
def test_maptoundefined(self):
self.assertRaises(UnicodeError, str, b'abc\001', codecname)
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index 552c521..c7003fb 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -436,7 +436,7 @@
del testme
import gc
gc.collect()
- self.assertEquals(["crab people, crab people"], x)
+ self.assertEqual(["crab people, crab people"], x)
def testBadTypeReturned(self):
# return values of some method are type-checked
@@ -529,17 +529,17 @@
a1 = A(1)
a2 = A(2)
- self.assertEquals(a1.f, a1.f)
- self.assertNotEquals(a1.f, a2.f)
- self.assertNotEquals(a1.f, a1.g)
- self.assertEquals(a1.f, A(1).f)
- self.assertEquals(hash(a1.f), hash(a1.f))
- self.assertEquals(hash(a1.f), hash(A(1).f))
+ self.assertEqual(a1.f, a1.f)
+ self.assertNotEqual(a1.f, a2.f)
+ self.assertNotEqual(a1.f, a1.g)
+ self.assertEqual(a1.f, A(1).f)
+ self.assertEqual(hash(a1.f), hash(a1.f))
+ self.assertEqual(hash(a1.f), hash(A(1).f))
- self.assertNotEquals(A.f, a1.f)
- self.assertNotEquals(A.f, A.g)
- self.assertEquals(B.f, A.f)
- self.assertEquals(hash(B.f), hash(A.f))
+ self.assertNotEqual(A.f, a1.f)
+ self.assertNotEqual(A.f, A.g)
+ self.assertEqual(B.f, A.f)
+ self.assertEqual(hash(B.f), hash(A.f))
# the following triggers a SystemError in 2.4
a = A(hash(A.f)^(-1))
diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py
index 6105fc0..c5b1e25 100644
--- a/Lib/test/test_codeccallbacks.py
+++ b/Lib/test/test_codeccallbacks.py
@@ -186,7 +186,7 @@
charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh")
sin = "abc"
sout = b"AABBCC"
- self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout)
+ self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout)
sin = "abcA"
self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap)
@@ -194,7 +194,7 @@
charmap[ord("?")] = b"XYZ"
sin = "abcDEF"
sout = b"AABBCCXYZXYZXYZ"
- self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout)
+ self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout)
charmap[ord("?")] = "XYZ" # wrong type in mapping
self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap)
@@ -327,7 +327,7 @@
# check with the correct number and type of arguments
exc = exctype(*args)
- self.assertEquals(str(exc), msg)
+ self.assertEqual(str(exc), msg)
def test_unicodeencodeerror(self):
self.check_exceptionobjectargs(
@@ -437,17 +437,17 @@
UnicodeError("ouch")
)
# If the correct exception is passed in, "ignore" returns an empty replacement
- self.assertEquals(
+ self.assertEqual(
codecs.ignore_errors(
UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")),
("", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.ignore_errors(
UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")),
("", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.ignore_errors(
UnicodeTranslateError("\u3042", 0, 1, "ouch")),
("", 1)
@@ -477,17 +477,17 @@
BadObjectUnicodeDecodeError()
)
# With the correct exception, "replace" returns an "?" or "\ufffd" replacement
- self.assertEquals(
+ self.assertEqual(
codecs.replace_errors(
UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")),
("?", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.replace_errors(
UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")),
("\ufffd", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.replace_errors(
UnicodeTranslateError("\u3042", 0, 1, "ouch")),
("\ufffd", 1)
@@ -520,7 +520,7 @@
# Use the correct exception
cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042)
s = "".join(chr(c) for c in cs)
- self.assertEquals(
+ self.assertEqual(
codecs.xmlcharrefreplace_errors(
UnicodeEncodeError("ascii", s, 0, len(s), "ouch")
),
@@ -552,52 +552,52 @@
UnicodeTranslateError("\u3042", 0, 1, "ouch")
)
# Use the correct exception
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")),
("\\u3042", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\x00", 0, 1, "ouch")),
("\\x00", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\xff", 0, 1, "ouch")),
("\\xff", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\u0100", 0, 1, "ouch")),
("\\u0100", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\uffff", 0, 1, "ouch")),
("\\uffff", 1)
)
# 1 on UCS-4 builds, 2 on UCS-2
len_wide = len("\U00010000")
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\U00010000",
0, len_wide, "ouch")),
("\\U00010000", len_wide)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\U0010ffff",
0, len_wide, "ouch")),
("\\U0010ffff", len_wide)
)
# Lone surrogates (regardless of unicode width)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\ud800", 0, 1, "ouch")),
("\\ud800", 1)
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors(
UnicodeEncodeError("ascii", "\udfff", 0, 1, "ouch")),
("\\udfff", 1)
@@ -630,14 +630,14 @@
)
def test_lookup(self):
- self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict"))
- self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore"))
- self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict"))
- self.assertEquals(
+ self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict"))
+ self.assertEqual(codecs.ignore_errors, codecs.lookup_error("ignore"))
+ self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict"))
+ self.assertEqual(
codecs.xmlcharrefreplace_errors,
codecs.lookup_error("xmlcharrefreplace")
)
- self.assertEquals(
+ self.assertEqual(
codecs.backslashreplace_errors,
codecs.lookup_error("backslashreplace")
)
@@ -713,11 +713,11 @@
# Valid negative position
handler.pos = -1
- self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
+ self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
# Valid negative position
handler.pos = -2
- self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>")
+ self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>")
# Negative position out of bounds
handler.pos = -3
@@ -725,11 +725,11 @@
# Valid positive position
handler.pos = 1
- self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
+ self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0")
# Largest valid positive position (one beyond end of input)
handler.pos = 2
- self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>")
+ self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>")
# Invalid positive position
handler.pos = 3
@@ -737,7 +737,7 @@
# Restart at the "0"
handler.pos = 6
- self.assertEquals(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0")
+ self.assertEqual(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0")
class D(dict):
def __getitem__(self, key):
@@ -767,11 +767,11 @@
# Valid negative position
handler.pos = -1
- self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
+ self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
# Valid negative position
handler.pos = -2
- self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?><?>")
+ self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?><?>")
# Negative position out of bounds
handler.pos = -3
@@ -779,11 +779,11 @@
# Valid positive position
handler.pos = 1
- self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
+ self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0")
# Largest valid positive position (one beyond end of input
handler.pos = 2
- self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>")
+ self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>")
# Invalid positive position
handler.pos = 3
diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py
index 5ee2d9f..93cdf91 100644
--- a/Lib/test/test_codecs.py
+++ b/Lib/test/test_codecs.py
@@ -300,7 +300,7 @@
# try to read it back
s = io.BytesIO(d)
f = reader(s)
- self.assertEquals(f.read(), "spamspam")
+ self.assertEqual(f.read(), "spamspam")
def test_badbom(self):
s = io.BytesIO(4*b"\xff")
@@ -464,7 +464,7 @@
# try to read it back
s = io.BytesIO(d)
f = reader(s)
- self.assertEquals(f.read(), "spamspam")
+ self.assertEqual(f.read(), "spamspam")
def test_badbom(self):
s = io.BytesIO(b"\xff\xff")
@@ -608,10 +608,10 @@
b'[?]')
def test_surrogatepass_handler(self):
- self.assertEquals("abc\ud800def".encode("utf-8", "surrogatepass"),
- b"abc\xed\xa0\x80def")
- self.assertEquals(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"),
- "abc\ud800def")
+ self.assertEqual("abc\ud800def".encode("utf-8", "surrogatepass"),
+ b"abc\xed\xa0\x80def")
+ self.assertEqual(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"),
+ "abc\ud800def")
self.assertTrue(codecs.lookup_error("surrogatepass"))
class UTF7Test(ReadTest):
@@ -694,7 +694,7 @@
def test_bug1601501(self):
# SF bug #1601501: check that the codec works with a buffer
- self.assertEquals(str(b"\xef\xbb\xbf", "utf-8-sig"), "")
+ self.assertEqual(str(b"\xef\xbb\xbf", "utf-8-sig"), "")
def test_bom(self):
d = codecs.getincrementaldecoder("utf-8-sig")()
@@ -747,7 +747,7 @@
class EscapeDecodeTest(unittest.TestCase):
def test_empty(self):
- self.assertEquals(codecs.escape_decode(""), ("", 0))
+ self.assertEqual(codecs.escape_decode(""), ("", 0))
class RecodingTest(unittest.TestCase):
def test_recoding(self):
@@ -874,16 +874,16 @@
# code produces only lower case. Converting just puny to
# lower is also insufficient, since some of the input characters
# are upper case.
- self.assertEquals(
+ self.assertEqual(
str(uni.encode("punycode"), "ascii").lower(),
str(puny, "ascii").lower()
)
def test_decode(self):
for uni, puny in punycode_testcases:
- self.assertEquals(uni, puny.decode("punycode"))
+ self.assertEqual(uni, puny.decode("punycode"))
puny = puny.decode("ascii").encode("ascii")
- self.assertEquals(uni, puny.decode("punycode"))
+ self.assertEqual(uni, puny.decode("punycode"))
class UnicodeInternalTest(unittest.TestCase):
def test_bug1251300(self):
@@ -905,7 +905,7 @@
for internal, uni in ok:
if sys.byteorder == "little":
internal = bytes(reversed(internal))
- self.assertEquals(uni, internal.decode("unicode_internal"))
+ self.assertEqual(uni, internal.decode("unicode_internal"))
for internal in not_ok:
if sys.byteorder == "little":
internal = bytes(reversed(internal))
@@ -917,10 +917,10 @@
try:
b"\x00\x00\x00\x00\x00\x11\x11\x00".decode("unicode_internal")
except UnicodeDecodeError as ex:
- self.assertEquals("unicode_internal", ex.encoding)
- self.assertEquals(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object)
- self.assertEquals(4, ex.start)
- self.assertEquals(8, ex.end)
+ self.assertEqual("unicode_internal", ex.encoding)
+ self.assertEqual(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object)
+ self.assertEqual(4, ex.start)
+ self.assertEqual(8, ex.end)
else:
self.fail()
@@ -932,15 +932,15 @@
ignored = decoder(bytes("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]),
"ascii"),
"UnicodeInternalTest")
- self.assertEquals(("ab", 12), ignored)
+ self.assertEqual(("ab", 12), ignored)
def test_encode_length(self):
# Issue 3739
encoder = codecs.getencoder("unicode_internal")
- self.assertEquals(encoder("a")[1], 1)
- self.assertEquals(encoder("\xe9\u0142")[1], 2)
+ self.assertEqual(encoder("a")[1], 1)
+ self.assertEqual(encoder("\xe9\u0142")[1], 2)
- self.assertEquals(codecs.escape_encode(br'\x00')[1], 4)
+ self.assertEqual(codecs.escape_encode(br'\x00')[1], 4)
# From http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html
nameprep_tests = [
@@ -1111,101 +1111,101 @@
else:
prepped = str(prepped, "utf-8", "surrogatepass")
try:
- self.assertEquals(nameprep(orig), prepped)
+ self.assertEqual(nameprep(orig), prepped)
except Exception as e:
raise support.TestFailed("Test 3.%d: %s" % (pos+1, str(e)))
class IDNACodecTest(unittest.TestCase):
def test_builtin_decode(self):
- self.assertEquals(str(b"python.org", "idna"), "python.org")
- self.assertEquals(str(b"python.org.", "idna"), "python.org.")
- self.assertEquals(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org")
- self.assertEquals(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
+ self.assertEqual(str(b"python.org", "idna"), "python.org")
+ self.assertEqual(str(b"python.org.", "idna"), "python.org.")
+ self.assertEqual(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org")
+ self.assertEqual(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
def test_builtin_encode(self):
- self.assertEquals("python.org".encode("idna"), b"python.org")
- self.assertEquals("python.org.".encode("idna"), b"python.org.")
- self.assertEquals("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org")
- self.assertEquals("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.")
+ self.assertEqual("python.org".encode("idna"), b"python.org")
+ self.assertEqual("python.org.".encode("idna"), b"python.org.")
+ self.assertEqual("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org")
+ self.assertEqual("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.")
def test_stream(self):
r = codecs.getreader("idna")(io.BytesIO(b"abc"))
r.read(3)
- self.assertEquals(r.read(), "")
+ self.assertEqual(r.read(), "")
def test_incremental_decode(self):
- self.assertEquals(
+ self.assertEqual(
"".join(codecs.iterdecode((bytes([c]) for c in b"python.org"), "idna")),
"python.org"
)
- self.assertEquals(
+ self.assertEqual(
"".join(codecs.iterdecode((bytes([c]) for c in b"python.org."), "idna")),
"python.org."
)
- self.assertEquals(
+ self.assertEqual(
"".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")),
"pyth\xf6n.org."
)
- self.assertEquals(
+ self.assertEqual(
"".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")),
"pyth\xf6n.org."
)
decoder = codecs.getincrementaldecoder("idna")()
- self.assertEquals(decoder.decode(b"xn--xam", ), "")
- self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.")
- self.assertEquals(decoder.decode(b"rg"), "")
- self.assertEquals(decoder.decode(b"", True), "org")
+ self.assertEqual(decoder.decode(b"xn--xam", ), "")
+ self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.")
+ self.assertEqual(decoder.decode(b"rg"), "")
+ self.assertEqual(decoder.decode(b"", True), "org")
decoder.reset()
- self.assertEquals(decoder.decode(b"xn--xam", ), "")
- self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.")
- self.assertEquals(decoder.decode(b"rg."), "org.")
- self.assertEquals(decoder.decode(b"", True), "")
+ self.assertEqual(decoder.decode(b"xn--xam", ), "")
+ self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.")
+ self.assertEqual(decoder.decode(b"rg."), "org.")
+ self.assertEqual(decoder.decode(b"", True), "")
def test_incremental_encode(self):
- self.assertEquals(
+ self.assertEqual(
b"".join(codecs.iterencode("python.org", "idna")),
b"python.org"
)
- self.assertEquals(
+ self.assertEqual(
b"".join(codecs.iterencode("python.org.", "idna")),
b"python.org."
)
- self.assertEquals(
+ self.assertEqual(
b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")),
b"xn--pythn-mua.org."
)
- self.assertEquals(
+ self.assertEqual(
b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")),
b"xn--pythn-mua.org."
)
encoder = codecs.getincrementalencoder("idna")()
- self.assertEquals(encoder.encode("\xe4x"), b"")
- self.assertEquals(encoder.encode("ample.org"), b"xn--xample-9ta.")
- self.assertEquals(encoder.encode("", True), b"org")
+ self.assertEqual(encoder.encode("\xe4x"), b"")
+ self.assertEqual(encoder.encode("ample.org"), b"xn--xample-9ta.")
+ self.assertEqual(encoder.encode("", True), b"org")
encoder.reset()
- self.assertEquals(encoder.encode("\xe4x"), b"")
- self.assertEquals(encoder.encode("ample.org."), b"xn--xample-9ta.org.")
- self.assertEquals(encoder.encode("", True), b"")
+ self.assertEqual(encoder.encode("\xe4x"), b"")
+ self.assertEqual(encoder.encode("ample.org."), b"xn--xample-9ta.org.")
+ self.assertEqual(encoder.encode("", True), b"")
class CodecsModuleTest(unittest.TestCase):
def test_decode(self):
- self.assertEquals(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'),
- '\xe4\xf6\xfc')
+ self.assertEqual(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'),
+ '\xe4\xf6\xfc')
self.assertRaises(TypeError, codecs.decode)
- self.assertEquals(codecs.decode(b'abc'), 'abc')
+ self.assertEqual(codecs.decode(b'abc'), 'abc')
self.assertRaises(UnicodeDecodeError, codecs.decode, b'\xff', 'ascii')
def test_encode(self):
- self.assertEquals(codecs.encode('\xe4\xf6\xfc', 'latin-1'),
- b'\xe4\xf6\xfc')
+ self.assertEqual(codecs.encode('\xe4\xf6\xfc', 'latin-1'),
+ b'\xe4\xf6\xfc')
self.assertRaises(TypeError, codecs.encode)
self.assertRaises(LookupError, codecs.encode, "foo", "__spam__")
- self.assertEquals(codecs.encode('abc'), b'abc')
+ self.assertEqual(codecs.encode('abc'), b'abc')
self.assertRaises(UnicodeEncodeError, codecs.encode, '\xffff', 'ascii')
def test_register(self):
@@ -1241,19 +1241,19 @@
def test_readlines(self):
f = self.reader(self.stream)
- self.assertEquals(f.readlines(), ['\ud55c\n', '\uae00'])
+ self.assertEqual(f.readlines(), ['\ud55c\n', '\uae00'])
class EncodedFileTest(unittest.TestCase):
def test_basic(self):
f = io.BytesIO(b'\xed\x95\x9c\n\xea\xb8\x80')
ef = codecs.EncodedFile(f, 'utf-16-le', 'utf-8')
- self.assertEquals(ef.read(), b'\\\xd5\n\x00\x00\xae')
+ self.assertEqual(ef.read(), b'\\\xd5\n\x00\x00\xae')
f = io.BytesIO()
ef = codecs.EncodedFile(f, 'utf-8', 'latin1')
ef.write(b'\xc3\xbc')
- self.assertEquals(f.getvalue(), b'\xfc')
+ self.assertEqual(f.getvalue(), b'\xfc')
all_unicode_encodings = [
"ascii",
@@ -1511,33 +1511,33 @@
class CharmapTest(unittest.TestCase):
def test_decode_with_string_map(self):
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(b"\x00\x01\x02", "strict", "abc"),
("abc", 3)
)
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab"),
("ab\ufffd", 3)
)
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab\ufffe"),
("ab\ufffd", 3)
)
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab"),
("ab", 3)
)
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab\ufffe"),
("ab", 3)
)
allbytes = bytes(range(256))
- self.assertEquals(
+ self.assertEqual(
codecs.charmap_decode(allbytes, "ignore", ""),
("", len(allbytes))
)
@@ -1546,14 +1546,14 @@
def test_encodedfile(self):
f = io.BytesIO(b"\xc3\xbc")
with codecs.EncodedFile(f, "latin-1", "utf-8") as ef:
- self.assertEquals(ef.read(), b"\xfc")
+ self.assertEqual(ef.read(), b"\xfc")
def test_streamreaderwriter(self):
f = io.BytesIO(b"\xc3\xbc")
info = codecs.lookup("utf-8")
with codecs.StreamReaderWriter(f, info.streamreader,
info.streamwriter, 'strict') as srw:
- self.assertEquals(srw.read(), "\xfc")
+ self.assertEqual(srw.read(), "\xfc")
class TypesTest(unittest.TestCase):
def test_decode_unicode(self):
@@ -1580,10 +1580,10 @@
def test_unicode_escape(self):
# Escape-decoding an unicode string is supported ang gives the same
# result as decoding the equivalent ASCII bytes string.
- self.assertEquals(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6))
- self.assertEquals(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6))
- self.assertEquals(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6))
- self.assertEquals(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6))
+ self.assertEqual(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6))
+ self.assertEqual(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6))
+ self.assertEqual(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6))
+ self.assertEqual(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6))
class SurrogateEscapeTest(unittest.TestCase):
@@ -1634,27 +1634,27 @@
f.write(data)
f.write(data)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
# Check that the BOM is written after a seek(0)
with codecs.open(support.TESTFN, 'w+', encoding=encoding) as f:
f.write(data[0])
- self.assertNotEquals(f.tell(), 0)
+ self.assertNotEqual(f.tell(), 0)
f.seek(0)
f.write(data)
f.seek(0)
- self.assertEquals(f.read(), data)
+ self.assertEqual(f.read(), data)
# (StreamWriter) Check that the BOM is written after a seek(0)
with codecs.open(support.TESTFN, 'w+', encoding=encoding) as f:
f.writer.write(data[0])
- self.assertNotEquals(f.writer.tell(), 0)
+ self.assertNotEqual(f.writer.tell(), 0)
f.writer.seek(0)
f.writer.write(data)
f.seek(0)
- self.assertEquals(f.read(), data)
+ self.assertEqual(f.read(), data)
# Check that the BOM is not written after a seek() at a position
# different than the start
@@ -1663,7 +1663,7 @@
f.seek(f.tell())
f.write(data)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
# (StreamWriter) Check that the BOM is not written after a seek()
# at a position different than the start
@@ -1672,7 +1672,7 @@
f.writer.seek(f.writer.tell())
f.writer.write(data)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
def test_main():
diff --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py
index ad44121..ffbcd34 100644
--- a/Lib/test/test_codeop.py
+++ b/Lib/test/test_codeop.py
@@ -37,14 +37,14 @@
ctx = {'a': 2}
d = { 'value': eval(code,ctx) }
r = { 'value': eval(str,ctx) }
- self.assertEquals(unify_callables(r),unify_callables(d))
+ self.assertEqual(unify_callables(r),unify_callables(d))
else:
expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT)
- self.assertEquals( compile_command(str, "<input>", symbol), expected)
+ self.assertEqual(compile_command(str, "<input>", symbol), expected)
def assertIncomplete(self, str, symbol='single'):
'''succeed iff str is the start of a valid piece of code'''
- self.assertEquals( compile_command(str, symbol=symbol), None)
+ self.assertEqual(compile_command(str, symbol=symbol), None)
def assertInvalid(self, str, symbol='single', is_syntax=1):
'''succeed iff str is the start of an invalid piece of code'''
@@ -61,12 +61,12 @@
# special case
if not is_jython:
- self.assertEquals(compile_command(""),
- compile("pass", "<input>", 'single',
- PyCF_DONT_IMPLY_DEDENT))
- self.assertEquals(compile_command("\n"),
- compile("pass", "<input>", 'single',
- PyCF_DONT_IMPLY_DEDENT))
+ self.assertEqual(compile_command(""),
+ compile("pass", "<input>", 'single',
+ PyCF_DONT_IMPLY_DEDENT))
+ self.assertEqual(compile_command("\n"),
+ compile("pass", "<input>", 'single',
+ PyCF_DONT_IMPLY_DEDENT))
else:
av("")
av("\n")
@@ -290,10 +290,10 @@
ai("[i for i in range(10)] = (1, 2, 3)")
def test_filename(self):
- self.assertEquals(compile_command("a = 1\n", "abc").co_filename,
- compile("a = 1\n", "abc", 'single').co_filename)
- self.assertNotEquals(compile_command("a = 1\n", "abc").co_filename,
- compile("a = 1\n", "def", 'single').co_filename)
+ self.assertEqual(compile_command("a = 1\n", "abc").co_filename,
+ compile("a = 1\n", "abc", 'single').co_filename)
+ self.assertNotEqual(compile_command("a = 1\n", "abc").co_filename,
+ compile("a = 1\n", "def", 'single').co_filename)
def test_no_universal_newlines(self):
code = compile_command("'\rfoo\r'", symbol='eval')
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index d435330..dc61fa4 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -535,10 +535,10 @@
# Test issue 9214
mymap = UserDict()
mymap['red'] = 5
- self.assert_(isinstance(mymap.keys(), Set))
- self.assert_(isinstance(mymap.keys(), KeysView))
- self.assert_(isinstance(mymap.items(), Set))
- self.assert_(isinstance(mymap.items(), ItemsView))
+ self.assertTrue(isinstance(mymap.keys(), Set))
+ self.assertTrue(isinstance(mymap.keys(), KeysView))
+ self.assertTrue(isinstance(mymap.items(), Set))
+ self.assertTrue(isinstance(mymap.items(), ItemsView))
mymap = UserDict()
mymap['red'] = 5
@@ -669,9 +669,9 @@
]):
msg = (i, dup, words)
self.assertTrue(dup is not words)
- self.assertEquals(dup, words)
- self.assertEquals(len(dup), len(words))
- self.assertEquals(type(dup), type(words))
+ self.assertEqual(dup, words)
+ self.assertEqual(len(dup), len(words))
+ self.assertEqual(type(dup), type(words))
def test_conversions(self):
# Convert to: set, list, dict
@@ -879,10 +879,10 @@
OrderedDict(od),
]):
self.assertTrue(dup is not od)
- self.assertEquals(dup, od)
- self.assertEquals(list(dup.items()), list(od.items()))
- self.assertEquals(len(dup), len(od))
- self.assertEquals(type(dup), type(od))
+ self.assertEqual(dup, od)
+ self.assertEqual(list(dup.items()), list(od.items()))
+ self.assertEqual(len(dup), len(od))
+ self.assertEqual(type(dup), type(od))
def test_yaml_linkage(self):
# Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.
diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index 52429ad..5173494 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -404,8 +404,8 @@
def test_plus_minus_0j(self):
# test that -0j and 0j literals are not identified
z1, z2 = 0j, -0j
- self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
- self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
+ self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.))
+ self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.))
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles")
diff --git a/Lib/test/test_copyreg.py b/Lib/test/test_copyreg.py
index 4fb89d0..bb3651e 100644
--- a/Lib/test/test_copyreg.py
+++ b/Lib/test/test_copyreg.py
@@ -40,7 +40,7 @@
def test_bool(self):
import copy
- self.assertEquals(True, copy.copy(True))
+ self.assertEqual(True, copy.copy(True))
def test_extension_registry(self):
mod, func, code = 'junk1 ', ' junk2', 0xabcd
@@ -101,16 +101,16 @@
mod, func, code)
def test_slotnames(self):
- self.assertEquals(copyreg._slotnames(WithoutSlots), [])
- self.assertEquals(copyreg._slotnames(WithWeakref), [])
+ self.assertEqual(copyreg._slotnames(WithoutSlots), [])
+ self.assertEqual(copyreg._slotnames(WithWeakref), [])
expected = ['_WithPrivate__spam']
- self.assertEquals(copyreg._slotnames(WithPrivate), expected)
- self.assertEquals(copyreg._slotnames(WithSingleString), ['spam'])
+ self.assertEqual(copyreg._slotnames(WithPrivate), expected)
+ self.assertEqual(copyreg._slotnames(WithSingleString), ['spam'])
expected = ['eggs', 'spam']
expected.sort()
result = copyreg._slotnames(WithInherited)
result.sort()
- self.assertEquals(result, expected)
+ self.assertEqual(result, expected)
def test_main():
diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py
index 5422fdf..d983d6e 100644
--- a/Lib/test/test_datetime.py
+++ b/Lib/test/test_datetime.py
@@ -1485,8 +1485,8 @@
def test_microsecond_rounding(self):
# Test whether fromtimestamp "rounds up" floats that are less
# than one microsecond smaller than an integer.
- self.assertEquals(self.theclass.fromtimestamp(0.9999999),
- self.theclass.fromtimestamp(1))
+ self.assertEqual(self.theclass.fromtimestamp(0.9999999),
+ self.theclass.fromtimestamp(1))
def test_insane_fromtimestamp(self):
# It's possible that some platform maps time_t to double,
@@ -1514,7 +1514,7 @@
@unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")
def test_negative_float_utcfromtimestamp(self):
d = self.theclass.utcfromtimestamp(-1.05)
- self.assertEquals(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
+ self.assertEqual(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
def test_utcnow(self):
import time
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 320a7a7..9c26ed3 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -4205,11 +4205,11 @@
__getattr__ = descr
self.assertRaises(AttributeError, getattr, A(), "attr")
- self.assertEquals(descr.counter, 1)
+ self.assertEqual(descr.counter, 1)
self.assertRaises(AttributeError, getattr, B(), "attr")
- self.assertEquals(descr.counter, 2)
+ self.assertEqual(descr.counter, 2)
self.assertRaises(AttributeError, getattr, C(), "attr")
- self.assertEquals(descr.counter, 4)
+ self.assertEqual(descr.counter, 4)
import gc
class EvilGetattribute(object):
@@ -4236,7 +4236,7 @@
# Testing dict-proxy iterkeys...
keys = [ key for key in self.C.__dict__.keys() ]
keys.sort()
- self.assertEquals(keys, ['__dict__', '__doc__', '__module__',
+ self.assertEqual(keys, ['__dict__', '__doc__', '__module__',
'__weakref__', 'meth'])
def test_iter_values(self):
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index 1519689..d1b1037 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -473,42 +473,42 @@
k2 = {1:1, 2:2, 3:3}.keys()
k3 = {4:4}.keys()
- self.assertEquals(k1 - k2, set())
- self.assertEquals(k1 - k3, {1,2})
- self.assertEquals(k2 - k1, {3})
- self.assertEquals(k3 - k1, {4})
- self.assertEquals(k1 & k2, {1,2})
- self.assertEquals(k1 & k3, set())
- self.assertEquals(k1 | k2, {1,2,3})
- self.assertEquals(k1 ^ k2, {3})
- self.assertEquals(k1 ^ k3, {1,2,4})
+ self.assertEqual(k1 - k2, set())
+ self.assertEqual(k1 - k3, {1,2})
+ self.assertEqual(k2 - k1, {3})
+ self.assertEqual(k3 - k1, {4})
+ self.assertEqual(k1 & k2, {1,2})
+ self.assertEqual(k1 & k3, set())
+ self.assertEqual(k1 | k2, {1,2,3})
+ self.assertEqual(k1 ^ k2, {3})
+ self.assertEqual(k1 ^ k3, {1,2,4})
def test_dictview_set_operations_on_items(self):
k1 = {1:1, 2:2}.items()
k2 = {1:1, 2:2, 3:3}.items()
k3 = {4:4}.items()
- self.assertEquals(k1 - k2, set())
- self.assertEquals(k1 - k3, {(1,1), (2,2)})
- self.assertEquals(k2 - k1, {(3,3)})
- self.assertEquals(k3 - k1, {(4,4)})
- self.assertEquals(k1 & k2, {(1,1), (2,2)})
- self.assertEquals(k1 & k3, set())
- self.assertEquals(k1 | k2, {(1,1), (2,2), (3,3)})
- self.assertEquals(k1 ^ k2, {(3,3)})
- self.assertEquals(k1 ^ k3, {(1,1), (2,2), (4,4)})
+ self.assertEqual(k1 - k2, set())
+ self.assertEqual(k1 - k3, {(1,1), (2,2)})
+ self.assertEqual(k2 - k1, {(3,3)})
+ self.assertEqual(k3 - k1, {(4,4)})
+ self.assertEqual(k1 & k2, {(1,1), (2,2)})
+ self.assertEqual(k1 & k3, set())
+ self.assertEqual(k1 | k2, {(1,1), (2,2), (3,3)})
+ self.assertEqual(k1 ^ k2, {(3,3)})
+ self.assertEqual(k1 ^ k3, {(1,1), (2,2), (4,4)})
def test_dictview_mixed_set_operations(self):
# Just a few for .keys()
self.assertTrue({1:1}.keys() == {1})
self.assertTrue({1} == {1:1}.keys())
- self.assertEquals({1:1}.keys() | {2}, {1, 2})
- self.assertEquals({2} | {1:1}.keys(), {1, 2})
+ self.assertEqual({1:1}.keys() | {2}, {1, 2})
+ self.assertEqual({2} | {1:1}.keys(), {1, 2})
# And a few for .items()
self.assertTrue({1:1}.items() == {(1,1)})
self.assertTrue({(1,1)} == {1:1}.items())
- self.assertEquals({1:1}.items() | {2}, {(1,1), 2})
- self.assertEquals({2} | {1:1}.items(), {(1,1), 2})
+ self.assertEqual({1:1}.items() | {2}, {(1,1), 2})
+ self.assertEqual({2} | {1:1}.items(), {(1,1), 2})
def test_missing(self):
# Make sure dict doesn't have a __missing__ method
diff --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py
index 847b991..14ac2d5 100644
--- a/Lib/test/test_epoll.py
+++ b/Lib/test/test_epoll.py
@@ -58,7 +58,7 @@
try:
client.connect(('127.0.0.1', self.serverSocket.getsockname()[1]))
except socket.error as e:
- self.assertEquals(e.args[0], errno.EINPROGRESS)
+ self.assertEqual(e.args[0], errno.EINPROGRESS)
else:
raise AssertionError("Connect should have raised EINPROGRESS")
server, addr = self.serverSocket.accept()
@@ -164,7 +164,7 @@
(server.fileno(), select.EPOLLOUT)]
expected.sort()
- self.assertEquals(events, expected)
+ self.assertEqual(events, expected)
self.assertFalse(then - now > 0.01, then - now)
now = time.time()
@@ -185,7 +185,7 @@
(server.fileno(), select.EPOLLIN | select.EPOLLOUT)]
expected.sort()
- self.assertEquals(events, expected)
+ self.assertEqual(events, expected)
ep.unregister(client.fileno())
ep.modify(server.fileno(), select.EPOLLOUT)
@@ -195,7 +195,7 @@
self.assertFalse(then - now > 0.01)
expected = [(server.fileno(), select.EPOLLOUT)]
- self.assertEquals(events, expected)
+ self.assertEqual(events, expected)
def test_errors(self):
self.assertRaises(ValueError, select.epoll, -2)
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 41e3d44..5b36186 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -22,8 +22,8 @@
raise exc("spam")
except exc as err:
buf2 = str(err)
- self.assertEquals(buf1, buf2)
- self.assertEquals(exc.__name__, excname)
+ self.assertEqual(buf1, buf2)
+ self.assertEqual(exc.__name__, excname)
def testRaising(self):
self.raise_catch(AttributeError, "AttributeError")
@@ -155,7 +155,7 @@
except TypeError as err:
exc, err, tb = sys.exc_info()
co = tb.tb_frame.f_code
- self.assertEquals(co.co_name, "test_capi1")
+ self.assertEqual(co.co_name, "test_capi1")
self.assertTrue(co.co_filename.endswith('test_exceptions.py'))
else:
self.fail("Expected exception")
@@ -167,10 +167,10 @@
except RuntimeError as err:
exc, err, tb = sys.exc_info()
co = tb.tb_frame.f_code
- self.assertEquals(co.co_name, "__init__")
+ self.assertEqual(co.co_name, "__init__")
self.assertTrue(co.co_filename.endswith('test_exceptions.py'))
co2 = tb.tb_frame.f_back.f_code
- self.assertEquals(co2.co_name, "test_capi2")
+ self.assertEqual(co2.co_name, "test_capi2")
else:
self.fail("Expected exception")
@@ -190,10 +190,9 @@
except NameError:
pass
else:
- self.assertEqual(str(WindowsError(1001)),
- "1001")
+ self.assertEqual(str(WindowsError(1001)), "1001")
self.assertEqual(str(WindowsError(1001, "message")),
- "[Error 1001] message")
+ "[Error 1001] message")
self.assertEqual(WindowsError(1001, "message").errno, 22)
self.assertEqual(WindowsError(1001, "message").winerror, 1001)
@@ -290,16 +289,16 @@
raise
else:
# Verify module name
- self.assertEquals(type(e).__module__, 'builtins')
+ self.assertEqual(type(e).__module__, 'builtins')
# Verify no ref leaks in Exc_str()
s = str(e)
for checkArgName in expected:
value = getattr(e, checkArgName)
- self.assertEquals(repr(value),
- repr(expected[checkArgName]),
- '%r.%s == %r, expected %r' % (
- e, checkArgName,
- value, expected[checkArgName]))
+ self.assertEqual(repr(value),
+ repr(expected[checkArgName]),
+ '%r.%s == %r, expected %r' % (
+ e, checkArgName,
+ value, expected[checkArgName]))
# test for pickling support
for p in [pickle]:
@@ -309,9 +308,9 @@
for checkArgName in expected:
got = repr(getattr(new, checkArgName))
want = repr(expected[checkArgName])
- self.assertEquals(got, want,
- 'pickled "%r", attribute "%s' %
- (e, checkArgName))
+ self.assertEqual(got, want,
+ 'pickled "%r", attribute "%s' %
+ (e, checkArgName))
def testWithTraceback(self):
try:
@@ -386,7 +385,7 @@
self.fancy_arg = fancy_arg
x = DerivedException(fancy_arg=42)
- self.assertEquals(x.fancy_arg, 42)
+ self.assertEqual(x.fancy_arg, 42)
def testInfiniteRecursion(self):
def f():
@@ -536,24 +535,24 @@
yield sys.exc_info()[0]
yield sys.exc_info()[0]
g = yield_raise()
- self.assertEquals(next(g), KeyError)
- self.assertEquals(sys.exc_info()[0], None)
- self.assertEquals(next(g), KeyError)
- self.assertEquals(sys.exc_info()[0], None)
- self.assertEquals(next(g), None)
+ self.assertEqual(next(g), KeyError)
+ self.assertEqual(sys.exc_info()[0], None)
+ self.assertEqual(next(g), KeyError)
+ self.assertEqual(sys.exc_info()[0], None)
+ self.assertEqual(next(g), None)
# Same test, but inside an exception handler
try:
raise TypeError("foo")
except TypeError:
g = yield_raise()
- self.assertEquals(next(g), KeyError)
- self.assertEquals(sys.exc_info()[0], TypeError)
- self.assertEquals(next(g), KeyError)
- self.assertEquals(sys.exc_info()[0], TypeError)
- self.assertEquals(next(g), TypeError)
+ self.assertEqual(next(g), KeyError)
+ self.assertEqual(sys.exc_info()[0], TypeError)
+ self.assertEqual(next(g), KeyError)
+ self.assertEqual(sys.exc_info()[0], TypeError)
+ self.assertEqual(next(g), TypeError)
del g
- self.assertEquals(sys.exc_info()[0], TypeError)
+ self.assertEqual(sys.exc_info()[0], TypeError)
def test_generator_finalizing_and_exc_info(self):
# See #7173
@@ -581,7 +580,7 @@
raise Exception(MyObject())
except:
pass
- self.assertEquals(e, (None, None, None))
+ self.assertEqual(e, (None, None, None))
def testUnicodeChangeAttributes(self):
# See issue 7309. This was a crasher.
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index bd2d7c0..30c6ed1 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -25,7 +25,7 @@
# verify weak references
p = proxy(self.f)
p.write(b'teststring')
- self.assertEquals(self.f.tell(), p.tell())
+ self.assertEqual(self.f.tell(), p.tell())
self.f.close()
self.f = None
self.assertRaises(ReferenceError, getattr, p, 'tell')
@@ -44,7 +44,7 @@
a = array('b', b'x'*10)
self.f = self.open(TESTFN, 'rb')
n = self.f.readinto(a)
- self.assertEquals(b'12', a.tostring()[:n])
+ self.assertEqual(b'12', a.tostring()[:n])
def testReadinto_text(self):
# verify readinto refuses text files
@@ -61,7 +61,7 @@
self.f.close()
self.f = self.open(TESTFN, 'rb')
buf = self.f.read()
- self.assertEquals(buf, b'12')
+ self.assertEqual(buf, b'12')
def testWritelinesIntegers(self):
# verify writelines with integers
@@ -82,7 +82,7 @@
def testErrors(self):
f = self.f
- self.assertEquals(f.name, TESTFN)
+ self.assertEqual(f.name, TESTFN)
self.assertTrue(not f.isatty())
self.assertTrue(not f.closed)
@@ -119,12 +119,12 @@
self.assertRaises(ValueError, method, *args)
# file is closed, __exit__ shouldn't do anything
- self.assertEquals(self.f.__exit__(None, None, None), None)
+ self.assertEqual(self.f.__exit__(None, None, None), None)
# it must also return None if an exception was given
try:
1/0
except:
- self.assertEquals(self.f.__exit__(*sys.exc_info()), None)
+ self.assertEqual(self.f.__exit__(*sys.exc_info()), None)
def testReadWhenWriting(self):
self.assertRaises(IOError, self.f.read)
@@ -190,7 +190,7 @@
f.close()
except IOError as msg:
self.fail('error setting buffer size %d: %s' % (s, str(msg)))
- self.assertEquals(d, s)
+ self.assertEqual(d, s)
def testTruncateOnWindows(self):
# SF bug <http://www.python.org/sf/801631>
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
index e9281e3..2a8e05d 100644
--- a/Lib/test/test_fileio.py
+++ b/Lib/test/test_fileio.py
@@ -29,31 +29,31 @@
# verify weak references
p = proxy(self.f)
p.write(bytes(range(10)))
- self.assertEquals(self.f.tell(), p.tell())
+ self.assertEqual(self.f.tell(), p.tell())
self.f.close()
self.f = None
self.assertRaises(ReferenceError, getattr, p, 'tell')
def testSeekTell(self):
self.f.write(bytes(range(20)))
- self.assertEquals(self.f.tell(), 20)
+ self.assertEqual(self.f.tell(), 20)
self.f.seek(0)
- self.assertEquals(self.f.tell(), 0)
+ self.assertEqual(self.f.tell(), 0)
self.f.seek(10)
- self.assertEquals(self.f.tell(), 10)
+ self.assertEqual(self.f.tell(), 10)
self.f.seek(5, 1)
- self.assertEquals(self.f.tell(), 15)
+ self.assertEqual(self.f.tell(), 15)
self.f.seek(-5, 1)
- self.assertEquals(self.f.tell(), 10)
+ self.assertEqual(self.f.tell(), 10)
self.f.seek(-5, 2)
- self.assertEquals(self.f.tell(), 15)
+ self.assertEqual(self.f.tell(), 15)
def testAttributes(self):
# verify expected attributes exist
f = self.f
- self.assertEquals(f.mode, "wb")
- self.assertEquals(f.closed, False)
+ self.assertEqual(f.mode, "wb")
+ self.assertEqual(f.closed, False)
# verify the attributes are readonly
for attr in 'mode', 'closed':
@@ -67,7 +67,7 @@
a = array('b', b'x'*10)
self.f = _FileIO(TESTFN, 'r')
n = self.f.readinto(a)
- self.assertEquals(array('b', [1, 2]), a[:n])
+ self.assertEqual(array('b', [1, 2]), a[:n])
def test_none_args(self):
self.f.write(b"hi\nbye\nabc")
@@ -82,19 +82,19 @@
self.assertRaises(TypeError, self.f.write, "Hello!")
def testRepr(self):
- self.assertEquals(repr(self.f), "<_io.FileIO name=%r mode=%r>"
+ self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode=%r>"
% (self.f.name, self.f.mode))
del self.f.name
- self.assertEquals(repr(self.f), "<_io.FileIO fd=%r mode=%r>"
+ self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode=%r>"
% (self.f.fileno(), self.f.mode))
self.f.close()
- self.assertEquals(repr(self.f), "<_io.FileIO [closed]>")
+ self.assertEqual(repr(self.f), "<_io.FileIO [closed]>")
def testErrors(self):
f = self.f
self.assertTrue(not f.isatty())
self.assertTrue(not f.closed)
- #self.assertEquals(f.name, TESTFN)
+ #self.assertEqual(f.name, TESTFN)
self.assertRaises(ValueError, f.read, 10) # Open for reading
f.close()
self.assertTrue(f.closed)
@@ -237,22 +237,22 @@
def testAbles(self):
try:
f = _FileIO(TESTFN, "w")
- self.assertEquals(f.readable(), False)
- self.assertEquals(f.writable(), True)
- self.assertEquals(f.seekable(), True)
+ self.assertEqual(f.readable(), False)
+ self.assertEqual(f.writable(), True)
+ self.assertEqual(f.seekable(), True)
f.close()
f = _FileIO(TESTFN, "r")
- self.assertEquals(f.readable(), True)
- self.assertEquals(f.writable(), False)
- self.assertEquals(f.seekable(), True)
+ self.assertEqual(f.readable(), True)
+ self.assertEqual(f.writable(), False)
+ self.assertEqual(f.seekable(), True)
f.close()
f = _FileIO(TESTFN, "a+")
- self.assertEquals(f.readable(), True)
- self.assertEquals(f.writable(), True)
- self.assertEquals(f.seekable(), True)
- self.assertEquals(f.isatty(), False)
+ self.assertEqual(f.readable(), True)
+ self.assertEqual(f.writable(), True)
+ self.assertEqual(f.seekable(), True)
+ self.assertEqual(f.isatty(), False)
f.close()
if sys.platform != "win32":
@@ -264,14 +264,14 @@
# OS'es that don't support /dev/tty.
pass
else:
- self.assertEquals(f.readable(), False)
- self.assertEquals(f.writable(), True)
+ self.assertEqual(f.readable(), False)
+ self.assertEqual(f.writable(), True)
if sys.platform != "darwin" and \
'bsd' not in sys.platform and \
not sys.platform.startswith('sunos'):
# Somehow /dev/tty appears seekable on some BSDs
- self.assertEquals(f.seekable(), False)
- self.assertEquals(f.isatty(), True)
+ self.assertEqual(f.seekable(), False)
+ self.assertEqual(f.isatty(), True)
f.close()
finally:
os.unlink(TESTFN)
@@ -305,7 +305,7 @@
f.write(b"abc")
f.close()
with open(TESTFN, "rb") as f:
- self.assertEquals(f.read(), b"abc")
+ self.assertEqual(f.read(), b"abc")
finally:
os.unlink(TESTFN)
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index bdaf082..fd8436a 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -341,8 +341,8 @@
return -0.0, math.atan2(0.0, -1)
def neg_neg():
return -0.0, math.atan2(-0.0, -1)
- self.assertEquals(pos_pos(), neg_pos())
- self.assertEquals(pos_neg(), neg_neg())
+ self.assertEqual(pos_pos(), neg_pos())
+ self.assertEqual(pos_neg(), neg_neg())
class FormatTestCase(unittest.TestCase):
def test_format(self):
@@ -415,9 +415,9 @@
self.assertEqual(fmt % -float(arg), '-' + rhs)
def test_issue5864(self):
- self.assertEquals(format(123.456, '.4'), '123.5')
- self.assertEquals(format(1234.56, '.4'), '1.235e+03')
- self.assertEquals(format(12345.6, '.4'), '1.235e+04')
+ self.assertEqual(format(123.456, '.4'), '123.5')
+ self.assertEqual(format(1234.56, '.4'), '1.235e+03')
+ self.assertEqual(format(12345.6, '.4'), '1.235e+04')
class ReprTestCase(unittest.TestCase):
def test_repr(self):
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index fd6588a..17fdb7f 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -79,16 +79,16 @@
class GcdTest(unittest.TestCase):
def testMisc(self):
- self.assertEquals(0, gcd(0, 0))
- self.assertEquals(1, gcd(1, 0))
- self.assertEquals(-1, gcd(-1, 0))
- self.assertEquals(1, gcd(0, 1))
- self.assertEquals(-1, gcd(0, -1))
- self.assertEquals(1, gcd(7, 1))
- self.assertEquals(-1, gcd(7, -1))
- self.assertEquals(1, gcd(-23, 15))
- self.assertEquals(12, gcd(120, 84))
- self.assertEquals(-12, gcd(84, -120))
+ self.assertEqual(0, gcd(0, 0))
+ self.assertEqual(1, gcd(1, 0))
+ self.assertEqual(-1, gcd(-1, 0))
+ self.assertEqual(1, gcd(0, 1))
+ self.assertEqual(-1, gcd(0, -1))
+ self.assertEqual(1, gcd(7, 1))
+ self.assertEqual(-1, gcd(7, -1))
+ self.assertEqual(1, gcd(-23, 15))
+ self.assertEqual(12, gcd(120, 84))
+ self.assertEqual(-12, gcd(84, -120))
def _components(r):
@@ -99,8 +99,8 @@
def assertTypedEquals(self, expected, actual):
"""Asserts that both the types and values are the same."""
- self.assertEquals(type(expected), type(actual))
- self.assertEquals(expected, actual)
+ self.assertEqual(type(expected), type(actual))
+ self.assertEqual(expected, actual)
def assertRaisesMessage(self, exc_type, message,
callable, *args, **kwargs):
@@ -108,25 +108,25 @@
try:
callable(*args, **kwargs)
except exc_type as e:
- self.assertEquals(message, str(e))
+ self.assertEqual(message, str(e))
else:
self.fail("%s not raised" % exc_type.__name__)
def testInit(self):
- self.assertEquals((0, 1), _components(F()))
- self.assertEquals((7, 1), _components(F(7)))
- self.assertEquals((7, 3), _components(F(F(7, 3))))
+ self.assertEqual((0, 1), _components(F()))
+ self.assertEqual((7, 1), _components(F(7)))
+ self.assertEqual((7, 3), _components(F(F(7, 3))))
- self.assertEquals((-1, 1), _components(F(-1, 1)))
- self.assertEquals((-1, 1), _components(F(1, -1)))
- self.assertEquals((1, 1), _components(F(-2, -2)))
- self.assertEquals((1, 2), _components(F(5, 10)))
- self.assertEquals((7, 15), _components(F(7, 15)))
- self.assertEquals((10**23, 1), _components(F(10**23)))
+ self.assertEqual((-1, 1), _components(F(-1, 1)))
+ self.assertEqual((-1, 1), _components(F(1, -1)))
+ self.assertEqual((1, 1), _components(F(-2, -2)))
+ self.assertEqual((1, 2), _components(F(5, 10)))
+ self.assertEqual((7, 15), _components(F(7, 15)))
+ self.assertEqual((10**23, 1), _components(F(10**23)))
- self.assertEquals((3, 77), _components(F(F(3, 7), 11)))
- self.assertEquals((-9, 5), _components(F(2, F(-10, 9))))
- self.assertEquals((2486, 2485), _components(F(F(22, 7), F(355, 113))))
+ self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
+ self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
+ self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
@@ -139,20 +139,20 @@
def testFromString(self):
- self.assertEquals((5, 1), _components(F("5")))
- self.assertEquals((3, 2), _components(F("3/2")))
- self.assertEquals((3, 2), _components(F(" \n +3/2")))
- self.assertEquals((-3, 2), _components(F("-3/2 ")))
- self.assertEquals((13, 2), _components(F(" 013/02 \n ")))
- self.assertEquals((16, 5), _components(F(" 3.2 ")))
- self.assertEquals((-16, 5), _components(F(" -3.2 ")))
- self.assertEquals((-3, 1), _components(F(" -3. ")))
- self.assertEquals((3, 5), _components(F(" .6 ")))
- self.assertEquals((1, 3125), _components(F("32.e-5")))
- self.assertEquals((1000000, 1), _components(F("1E+06")))
- self.assertEquals((-12300, 1), _components(F("-1.23e4")))
- self.assertEquals((0, 1), _components(F(" .0e+0\t")))
- self.assertEquals((0, 1), _components(F("-0.000e0")))
+ self.assertEqual((5, 1), _components(F("5")))
+ self.assertEqual((3, 2), _components(F("3/2")))
+ self.assertEqual((3, 2), _components(F(" \n +3/2")))
+ self.assertEqual((-3, 2), _components(F("-3/2 ")))
+ self.assertEqual((13, 2), _components(F(" 013/02 \n ")))
+ self.assertEqual((16, 5), _components(F(" 3.2 ")))
+ self.assertEqual((-16, 5), _components(F(" -3.2 ")))
+ self.assertEqual((-3, 1), _components(F(" -3. ")))
+ self.assertEqual((3, 5), _components(F(" .6 ")))
+ self.assertEqual((1, 3125), _components(F("32.e-5")))
+ self.assertEqual((1000000, 1), _components(F("1E+06")))
+ self.assertEqual((-12300, 1), _components(F("-1.23e4")))
+ self.assertEqual((0, 1), _components(F(" .0e+0\t")))
+ self.assertEqual((0, 1), _components(F("-0.000e0")))
self.assertRaisesMessage(
ZeroDivisionError, "Fraction(3, 0)",
@@ -194,33 +194,33 @@
def testImmutable(self):
r = F(7, 3)
r.__init__(2, 15)
- self.assertEquals((7, 3), _components(r))
+ self.assertEqual((7, 3), _components(r))
self.assertRaises(AttributeError, setattr, r, 'numerator', 12)
self.assertRaises(AttributeError, setattr, r, 'denominator', 6)
- self.assertEquals((7, 3), _components(r))
+ self.assertEqual((7, 3), _components(r))
# But if you _really_ need to:
r._numerator = 4
r._denominator = 2
- self.assertEquals((4, 2), _components(r))
+ self.assertEqual((4, 2), _components(r))
# Which breaks some important operations:
- self.assertNotEquals(F(4, 2), r)
+ self.assertNotEqual(F(4, 2), r)
def testFromFloat(self):
self.assertRaises(TypeError, F.from_float, 3+4j)
- self.assertEquals((10, 1), _components(F.from_float(10)))
+ self.assertEqual((10, 1), _components(F.from_float(10)))
bigint = 1234567890123456789
- self.assertEquals((bigint, 1), _components(F.from_float(bigint)))
- self.assertEquals((0, 1), _components(F.from_float(-0.0)))
- self.assertEquals((10, 1), _components(F.from_float(10.0)))
- self.assertEquals((-5, 2), _components(F.from_float(-2.5)))
- self.assertEquals((99999999999999991611392, 1),
+ self.assertEqual((bigint, 1), _components(F.from_float(bigint)))
+ self.assertEqual((0, 1), _components(F.from_float(-0.0)))
+ self.assertEqual((10, 1), _components(F.from_float(10.0)))
+ self.assertEqual((-5, 2), _components(F.from_float(-2.5)))
+ self.assertEqual((99999999999999991611392, 1),
_components(F.from_float(1e23)))
- self.assertEquals(float(10**23), float(F.from_float(1e23)))
- self.assertEquals((3602879701896397, 1125899906842624),
+ self.assertEqual(float(10**23), float(F.from_float(1e23)))
+ self.assertEqual((3602879701896397, 1125899906842624),
_components(F.from_float(3.2)))
- self.assertEquals(3.2, float(F.from_float(3.2)))
+ self.assertEqual(3.2, float(F.from_float(3.2)))
inf = 1e1000
nan = inf - inf
@@ -236,13 +236,13 @@
def testFromDecimal(self):
self.assertRaises(TypeError, F.from_decimal, 3+4j)
- self.assertEquals(F(10, 1), F.from_decimal(10))
- self.assertEquals(F(0), F.from_decimal(Decimal("-0")))
- self.assertEquals(F(5, 10), F.from_decimal(Decimal("0.5")))
- self.assertEquals(F(5, 1000), F.from_decimal(Decimal("5e-3")))
- self.assertEquals(F(5000), F.from_decimal(Decimal("5e3")))
- self.assertEquals(1 - F(1, 10**30),
- F.from_decimal(Decimal("0." + "9" * 30)))
+ self.assertEqual(F(10, 1), F.from_decimal(10))
+ self.assertEqual(F(0), F.from_decimal(Decimal("-0")))
+ self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5")))
+ self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3")))
+ self.assertEqual(F(5000), F.from_decimal(Decimal("5e3")))
+ self.assertEqual(1 - F(1, 10**30),
+ F.from_decimal(Decimal("0." + "9" * 30)))
self.assertRaisesMessage(
TypeError, "Cannot convert Infinity to Fraction.",
@@ -278,15 +278,15 @@
self.assertTypedEquals(-2, round(F(-15, 10)))
self.assertTypedEquals(-1, round(F(-7, 10)))
- self.assertEquals(False, bool(F(0, 1)))
- self.assertEquals(True, bool(F(3, 2)))
+ self.assertEqual(False, bool(F(0, 1)))
+ self.assertEqual(True, bool(F(3, 2)))
self.assertTypedEquals(0.1, float(F(1, 10)))
# Check that __float__ isn't implemented by converting the
# numerator and denominator to float before dividing.
self.assertRaises(OverflowError, float, int('2'*400+'7'))
- self.assertAlmostEquals(2.0/3,
- float(F(int('2'*400+'7'), int('3'*400+'1'))))
+ self.assertAlmostEqual(2.0/3,
+ float(F(int('2'*400+'7'), int('3'*400+'1'))))
self.assertTypedEquals(0.1+0j, complex(F(1,10)))
@@ -299,19 +299,19 @@
def testArithmetic(self):
- self.assertEquals(F(1, 2), F(1, 10) + F(2, 5))
- self.assertEquals(F(-3, 10), F(1, 10) - F(2, 5))
- self.assertEquals(F(1, 25), F(1, 10) * F(2, 5))
- self.assertEquals(F(1, 4), F(1, 10) / F(2, 5))
+ self.assertEqual(F(1, 2), F(1, 10) + F(2, 5))
+ self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5))
+ self.assertEqual(F(1, 25), F(1, 10) * F(2, 5))
+ self.assertEqual(F(1, 4), F(1, 10) / F(2, 5))
self.assertTypedEquals(2, F(9, 10) // F(2, 5))
self.assertTypedEquals(10**23, F(10**23, 1) // F(1))
- self.assertEquals(F(2, 3), F(-7, 3) % F(3, 2))
- self.assertEquals(F(8, 27), F(2, 3) ** F(3))
- self.assertEquals(F(27, 8), F(2, 3) ** F(-3))
+ self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2))
+ self.assertEqual(F(8, 27), F(2, 3) ** F(3))
+ self.assertEqual(F(27, 8), F(2, 3) ** F(-3))
self.assertTypedEquals(2.0, F(4) ** F(1, 2))
z = pow(F(-1), F(1, 2))
- self.assertAlmostEquals(z.real, 0)
- self.assertEquals(z.imag, 1)
+ self.assertAlmostEqual(z.real, 0)
+ self.assertEqual(z.imag, 1)
def testMixedArithmetic(self):
self.assertTypedEquals(F(11, 10), F(1, 10) + 1)
@@ -362,8 +362,8 @@
self.assertTypedEquals(0.1 + 0j, F(1, 10) ** (1.0 + 0j))
self.assertTypedEquals(4 , 2 ** F(2, 1))
z = pow(-1, F(1, 2))
- self.assertAlmostEquals(0, z.real)
- self.assertEquals(1, z.imag)
+ self.assertAlmostEqual(0, z.real)
+ self.assertEqual(1, z.imag)
self.assertTypedEquals(F(1, 4) , 2 ** F(-2, 1))
self.assertTypedEquals(2.0 , 4 ** F(1, 2))
self.assertTypedEquals(0.25, 2.0 ** F(-2, 1))
@@ -375,7 +375,7 @@
TypeError,
"unsupported operand type(s) for +: 'Fraction' and 'Decimal'",
operator.add, F(3,11), Decimal('3.1415926'))
- self.assertNotEquals(F(5, 2), Decimal('2.5'))
+ self.assertNotEqual(F(5, 2), Decimal('2.5'))
def testComparisons(self):
self.assertTrue(F(1, 2) < F(2, 3))
@@ -497,18 +497,18 @@
self.assertFalse(float('-inf') == F(2, 5))
def testStringification(self):
- self.assertEquals("Fraction(7, 3)", repr(F(7, 3)))
- self.assertEquals("Fraction(6283185307, 2000000000)",
+ self.assertEqual("Fraction(7, 3)", repr(F(7, 3)))
+ self.assertEqual("Fraction(6283185307, 2000000000)",
repr(F('3.1415926535')))
- self.assertEquals("Fraction(-1, 100000000000000000000)",
+ self.assertEqual("Fraction(-1, 100000000000000000000)",
repr(F(1, -10**20)))
- self.assertEquals("7/3", str(F(7, 3)))
- self.assertEquals("7", str(F(7, 1)))
+ self.assertEqual("7/3", str(F(7, 3)))
+ self.assertEqual("7", str(F(7, 1)))
def testHash(self):
- self.assertEquals(hash(2.5), hash(F(5, 2)))
- self.assertEquals(hash(10**50), hash(F(10**50)))
- self.assertNotEquals(hash(float(10**23)), hash(F(10**23)))
+ self.assertEqual(hash(2.5), hash(F(5, 2)))
+ self.assertEqual(hash(10**50), hash(F(10**50)))
+ self.assertNotEqual(hash(float(10**23)), hash(F(10**23)))
def testApproximatePi(self):
# Algorithm borrowed from
@@ -521,7 +521,7 @@
d, da = d+da, da+32
t = (t * n) / d
s += t
- self.assertAlmostEquals(math.pi, s)
+ self.assertAlmostEqual(math.pi, s)
def testApproximateCos1(self):
# Algorithm borrowed from
@@ -535,7 +535,7 @@
num *= x * x
sign *= -1
s += num / fact * sign
- self.assertAlmostEquals(math.cos(1), s)
+ self.assertAlmostEqual(math.cos(1), s)
def test_copy_deepcopy_pickle(self):
r = F(13, 7)
diff --git a/Lib/test/test_frozen.py b/Lib/test/test_frozen.py
index ab7b52f..d072145 100644
--- a/Lib/test/test_frozen.py
+++ b/Lib/test/test_frozen.py
@@ -22,7 +22,7 @@
self.assertEqual(len(dir(__phello__)), 7, dir(__phello__))
else:
self.assertEqual(len(dir(__phello__)), 8, dir(__phello__))
- self.assertEquals(__phello__.__path__, [__phello__.__name__])
+ self.assertEqual(__phello__.__path__, [__phello__.__name__])
try:
import __phello__.spam
diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py
index 3ffc1cc..1e88a34 100644
--- a/Lib/test/test_getargs2.py
+++ b/Lib/test/test_getargs2.py
@@ -239,7 +239,7 @@
from _testcapi import getargs_tuple
ret = getargs_tuple(1, (2, 3))
- self.assertEquals(ret, (1,2,3))
+ self.assertEqual(ret, (1,2,3))
# make sure invalid tuple arguments are handled correctly
class seq:
@@ -252,25 +252,25 @@
class Keywords_TestCase(unittest.TestCase):
def test_positional_args(self):
# using all positional args
- self.assertEquals(
+ self.assertEqual(
getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10),
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
)
def test_mixed_args(self):
# positional and keyword args
- self.assertEquals(
+ self.assertEqual(
getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10),
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
)
def test_keyword_args(self):
# all keywords
- self.assertEquals(
+ self.assertEqual(
getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10),
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
)
def test_optional_args(self):
# missing optional keyword args, skipping tuples
- self.assertEquals(
+ self.assertEqual(
getargs_keywords(arg1=(1,2), arg2=3, arg5=10),
(1, 2, 3, -1, -1, -1, -1, -1, -1, 10)
)
@@ -279,14 +279,14 @@
try:
getargs_keywords(arg1=(1,2))
except TypeError as err:
- self.assertEquals(str(err), "Required argument 'arg2' (pos 2) not found")
+ self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found")
else:
self.fail('TypeError should have been raised')
def test_too_many_args(self):
try:
getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111)
except TypeError as err:
- self.assertEquals(str(err), "function takes at most 5 arguments (6 given)")
+ self.assertEqual(str(err), "function takes at most 5 arguments (6 given)")
else:
self.fail('TypeError should have been raised')
def test_invalid_keyword(self):
@@ -294,7 +294,7 @@
try:
getargs_keywords((1,2),3,arg5=10,arg666=666)
except TypeError as err:
- self.assertEquals(str(err), "'arg666' is an invalid keyword argument for this function")
+ self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function")
else:
self.fail('TypeError should have been raised')
diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py
index f6f9d2e..0f47fcb 100644
--- a/Lib/test/test_getopt.py
+++ b/Lib/test/test_getopt.py
@@ -176,9 +176,9 @@
def test_issue4629(self):
longopts, shortopts = getopt.getopt(['--help='], '', ['help='])
- self.assertEquals(longopts, [('--help', '')])
+ self.assertEqual(longopts, [('--help', '')])
longopts, shortopts = getopt.getopt(['--help=x'], '', ['help='])
- self.assertEquals(longopts, [('--help', 'x')])
+ self.assertEqual(longopts, [('--help', 'x')])
self.assertRaises(getopt.GetoptError, getopt.getopt, ['--help='], '', ['help'])
def test_main():
diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py
index adaea18..f92d304 100644
--- a/Lib/test/test_glob.py
+++ b/Lib/test/test_glob.py
@@ -59,8 +59,8 @@
if set(type(x) for x in tmp) == uniset:
u1 = glob.glob('*')
u2 = glob.glob('./*')
- self.assertEquals(set(type(r) for r in u1), uniset)
- self.assertEquals(set(type(r) for r in u2), uniset)
+ self.assertEqual(set(type(r) for r in u1), uniset)
+ self.assertEqual(set(type(r) for r in u2), uniset)
def test_glob_one_directory(self):
eq = self.assertSequencesEqual_noorder
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index b861207..ff8dc93 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -20,23 +20,23 @@
# Backslash means line continuation:
x = 1 \
+ 1
- self.assertEquals(x, 2, 'backslash for line continuation')
+ self.assertEqual(x, 2, 'backslash for line continuation')
# Backslash does not means continuation in comments :\
x = 0
- self.assertEquals(x, 0, 'backslash ending comment')
+ self.assertEqual(x, 0, 'backslash ending comment')
def testPlainIntegers(self):
- self.assertEquals(type(000), type(0))
- self.assertEquals(0xff, 255)
- self.assertEquals(0o377, 255)
- self.assertEquals(2147483647, 0o17777777777)
- self.assertEquals(0b1001, 9)
+ self.assertEqual(type(000), type(0))
+ self.assertEqual(0xff, 255)
+ self.assertEqual(0o377, 255)
+ self.assertEqual(2147483647, 0o17777777777)
+ self.assertEqual(0b1001, 9)
# "0x" is not a valid literal
self.assertRaises(SyntaxError, eval, "0x")
from sys import maxsize
if maxsize == 2147483647:
- self.assertEquals(-2147483647-1, -0o20000000000)
+ self.assertEqual(-2147483647-1, -0o20000000000)
# XXX -2147483648
self.assertTrue(0o37777777777 > 0)
self.assertTrue(0xffffffff > 0)
@@ -48,7 +48,7 @@
except OverflowError:
self.fail("OverflowError on huge integer literal %r" % s)
elif maxsize == 9223372036854775807:
- self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
+ self.assertEqual(-9223372036854775807-1, -0o1000000000000000000000)
self.assertTrue(0o1777777777777777777777 > 0)
self.assertTrue(0xffffffffffffffff > 0)
self.assertTrue(0b11111111111111111111111111111111111111111111111111111111111111 > 0)
@@ -103,28 +103,28 @@
the 'lazy' dog.
"""
y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
- self.assertEquals(x, y)
+ self.assertEqual(x, y)
y = '''
The "quick"
brown fox
jumps over
the 'lazy' dog.
'''
- self.assertEquals(x, y)
+ self.assertEqual(x, y)
y = "\n\
The \"quick\"\n\
brown fox\n\
jumps over\n\
the 'lazy' dog.\n\
"
- self.assertEquals(x, y)
+ self.assertEqual(x, y)
y = '\n\
The \"quick\"\n\
brown fox\n\
jumps over\n\
the \'lazy\' dog.\n\
'
- self.assertEquals(x, y)
+ self.assertEqual(x, y)
def testEllipsis(self):
x = ...
@@ -165,8 +165,8 @@
f1(*(), **{})
def f2(one_argument): pass
def f3(two, arguments): pass
- self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
- self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
+ self.assertEqual(f2.__code__.co_varnames, ('one_argument',))
+ self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments'))
def a1(one_arg,): pass
def a2(two, args,): pass
def v0(*rest): pass
@@ -287,37 +287,37 @@
# keyword arguments after *arglist
def f(*args, **kwargs):
return args, kwargs
- self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
+ self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
{'x':2, 'y':5}))
self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
# argument annotation tests
def f(x) -> list: pass
- self.assertEquals(f.__annotations__, {'return': list})
+ self.assertEqual(f.__annotations__, {'return': list})
def f(x:int): pass
- self.assertEquals(f.__annotations__, {'x': int})
+ self.assertEqual(f.__annotations__, {'x': int})
def f(*x:str): pass
- self.assertEquals(f.__annotations__, {'x': str})
+ self.assertEqual(f.__annotations__, {'x': str})
def f(**x:float): pass
- self.assertEquals(f.__annotations__, {'x': float})
+ self.assertEqual(f.__annotations__, {'x': float})
def f(x, y:1+2): pass
- self.assertEquals(f.__annotations__, {'y': 3})
+ self.assertEqual(f.__annotations__, {'y': 3})
def f(a, b:1, c:2, d): pass
- self.assertEquals(f.__annotations__, {'b': 1, 'c': 2})
+ self.assertEqual(f.__annotations__, {'b': 1, 'c': 2})
def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass
- self.assertEquals(f.__annotations__,
- {'b': 1, 'c': 2, 'e': 3, 'g': 6})
+ self.assertEqual(f.__annotations__,
+ {'b': 1, 'c': 2, 'e': 3, 'g': 6})
def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10,
**k:11) -> 12: pass
- self.assertEquals(f.__annotations__,
- {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
- 'k': 11, 'return': 12})
+ self.assertEqual(f.__annotations__,
+ {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
+ 'k': 11, 'return': 12})
# Check for SF Bug #1697248 - mixing decorators and a return annotation
def null(x): return x
@null
def f(x) -> list: pass
- self.assertEquals(f.__annotations__, {'return': list})
+ self.assertEqual(f.__annotations__, {'return': list})
# test MAKE_CLOSURE with a variety of oparg's
closure = 1
@@ -333,20 +333,20 @@
def testLambdef(self):
### lambdef: 'lambda' [varargslist] ':' test
l1 = lambda : 0
- self.assertEquals(l1(), 0)
+ self.assertEqual(l1(), 0)
l2 = lambda : a[d] # XXX just testing the expression
l3 = lambda : [2 < x for x in [-1, 3, 0]]
- self.assertEquals(l3(), [0, 1, 0])
+ self.assertEqual(l3(), [0, 1, 0])
l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
- self.assertEquals(l4(), 1)
+ self.assertEqual(l4(), 1)
l5 = lambda x, y, z=2: x + y + z
- self.assertEquals(l5(1, 2), 5)
- self.assertEquals(l5(1, 2, 3), 6)
+ self.assertEqual(l5(1, 2), 5)
+ self.assertEqual(l5(1, 2, 3), 6)
check_syntax_error(self, "lambda x: x = 2")
check_syntax_error(self, "lambda (None,): None")
l6 = lambda x, y, *, k=20: x+y+k
- self.assertEquals(l6(1,2), 1+2+20)
- self.assertEquals(l6(1,2,k=10), 1+2+10)
+ self.assertEqual(l6(1,2), 1+2+20)
+ self.assertEqual(l6(1,2,k=10), 1+2+10)
### stmt: simple_stmt | compound_stmt
@@ -502,7 +502,7 @@
try:
assert 0, "msg"
except AssertionError as e:
- self.assertEquals(e.args[0], "msg")
+ self.assertEqual(e.args[0], "msg")
else:
if __debug__:
self.fail("AssertionError not raised by assert 0")
@@ -536,7 +536,7 @@
x = 1
else:
x = 2
- self.assertEquals(x, 2)
+ self.assertEqual(x, 2)
def testFor(self):
# 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
@@ -688,7 +688,7 @@
d[1,2,3] = 4
L = list(d)
L.sort(key=lambda x: x if isinstance(x, tuple) else ())
- self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
+ self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
def testAtoms(self):
### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING
diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py
index a4a7e24..b992384 100644
--- a/Lib/test/test_gzip.py
+++ b/Lib/test/test_gzip.py
@@ -101,7 +101,7 @@
contents += ztxt
if not ztxt: break
zgfile.close()
- self.assertEquals(contents, b'a'*201)
+ self.assertEqual(contents, b'a'*201)
def test_readline(self):
@@ -160,7 +160,7 @@
f.seek(10, whence=1)
y = f.read(10)
f.close()
- self.assertEquals(y, data1[20:30])
+ self.assertEqual(y, data1[20:30])
def test_seek_write(self):
# Try seek, write test
diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
index 94635e1..dca23cf 100644
--- a/Lib/test/test_hashlib.py
+++ b/Lib/test/test_hashlib.py
@@ -224,10 +224,10 @@
m.update(b'1')
m.update(b'#' * gil_minsize)
m.update(b'1')
- self.assertEquals(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21')
+ self.assertEqual(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21')
m = hashlib.md5(b'x' * gil_minsize)
- self.assertEquals(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958')
+ self.assertEqual(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958')
def test_threaded_hashing(self):
if not threading:
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index d495586..3e85f62 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -20,10 +20,10 @@
def test_time2isoz(self):
base = 1019227000
day = 24*3600
- self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z")
- self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z")
- self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
- self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
+ self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z")
+ self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z")
+ self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
+ self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
az = time2isoz()
bz = time2isoz(500000)
@@ -35,13 +35,13 @@
def parse_date(text):
return time.gmtime(http2time(text))[:6]
- self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
+ self.assertEqual(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
# this test will break around year 2070
- self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
+ self.assertEqual(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
# this test will break around year 2048
- self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
+ self.assertEqual(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
def test_http2time_formats(self):
# test http2time for supported dates. Test cases with 2 digit year
@@ -69,8 +69,8 @@
test_t = 760233600 # assume broken POSIX counting of seconds
result = time2isoz(test_t)
expected = "1994-02-03 00:00:00Z"
- self.assertEquals(result, expected,
- "%s => '%s' (%s)" % (test_t, result, expected))
+ self.assertEqual(result, expected,
+ "%s => '%s' (%s)" % (test_t, result, expected))
for s in tests:
t = http2time(s)
@@ -107,7 +107,7 @@
'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
]:
- self.assertEquals(parse_ns_headers([hdr]), expected)
+ self.assertEqual(parse_ns_headers([hdr]), expected)
def test_parse_ns_headers_special_names(self):
# names such as 'expires' are not special in first name=value pair
@@ -115,13 +115,13 @@
# Cookie with name 'expires'
hdr = 'expires=01 Jan 2040 22:23:32 GMT'
expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]]
- self.assertEquals(parse_ns_headers([hdr]), expected)
+ self.assertEqual(parse_ns_headers([hdr]), expected)
def test_join_header_words(self):
joined = join_header_words([[("foo", None), ("bar", "baz")]])
- self.assertEquals(joined, "foo; bar=baz")
+ self.assertEqual(joined, "foo; bar=baz")
- self.assertEquals(join_header_words([[]]), "")
+ self.assertEqual(join_header_words([[]]), "")
def test_split_header_words(self):
tests = [
@@ -151,7 +151,7 @@
f = io.StringIO()
traceback.print_exc(None, f)
result = "(error -- traceback follows)\n\n%s" % f.getvalue()
- self.assertEquals(result, expect, """
+ self.assertEqual(result, expect, """
When parsing: '%s'
Expected: '%s'
Got: '%s'
@@ -183,7 +183,7 @@
for arg, expect in tests:
input = split_header_words([arg])
res = join_header_words(input)
- self.assertEquals(res, expect, """
+ self.assertEqual(res, expect, """
When parsing: '%s'
Expected: '%s'
Got: '%s'
@@ -347,11 +347,11 @@
interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/')
cookie = c._cookies["www.acme.com"]["/"]["eggs"]
self.assertTrue(cookie.value is None)
- self.assertEquals(cookie.name, "eggs")
+ self.assertEqual(cookie.name, "eggs")
cookie = c._cookies["www.acme.com"]['/foo/']['"spam"']
self.assertTrue(cookie.value is None)
- self.assertEquals(cookie.name, '"spam"')
- self.assertEquals(lwp_cookie_str(cookie), (
+ self.assertEqual(cookie.name, '"spam"')
+ self.assertEqual(lwp_cookie_str(cookie), (
r'"spam"; path="/foo/"; domain="www.acme.com"; '
'path_spec; discard; version=0'))
old_str = repr(c)
@@ -362,13 +362,13 @@
finally:
os.unlink(c.filename)
# cookies unchanged apart from lost info re. whether path was specified
- self.assertEquals(
+ self.assertEqual(
repr(c),
re.sub("path_specified=%s" % True, "path_specified=%s" % False,
old_str)
)
- self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"),
- '"spam"; eggs')
+ self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"),
+ '"spam"; eggs')
def test_rfc2109_handling(self):
# RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
@@ -412,18 +412,18 @@
'expires="Foo Bar 25 33:22:11 3022"')
cookie = c._cookies[".acme.com"]["/"]["spam"]
- self.assertEquals(cookie.domain, ".acme.com")
+ self.assertEqual(cookie.domain, ".acme.com")
self.assertTrue(cookie.domain_specified)
- self.assertEquals(cookie.port, DEFAULT_HTTP_PORT)
+ self.assertEqual(cookie.port, DEFAULT_HTTP_PORT)
self.assertTrue(not cookie.port_specified)
# case is preserved
self.assertTrue(cookie.has_nonstandard_attr("blArgh") and
not cookie.has_nonstandard_attr("blargh"))
cookie = c._cookies["www.acme.com"]["/"]["ni"]
- self.assertEquals(cookie.domain, "www.acme.com")
+ self.assertEqual(cookie.domain, "www.acme.com")
self.assertTrue(not cookie.domain_specified)
- self.assertEquals(cookie.port, "80,8080")
+ self.assertEqual(cookie.port, "80,8080")
self.assertTrue(cookie.port_specified)
cookie = c._cookies["www.acme.com"]["/"]["nini"]
@@ -453,13 +453,13 @@
future = time2netscape(time.time()+3600)
interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' %
future)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
now = time2netscape(time.time()-1)
# ... and if in past or present, discard it
interact_netscape(c, "http://www.acme.com/", 'foo="eggs"; expires=%s' %
now)
h = interact_netscape(c, "http://www.acme.com/")
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
self.assertTrue('spam="bar"' in h and "foo" not in h)
# max-age takes precedence over expires, and zero max-age is request to
@@ -468,19 +468,19 @@
future)
interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' %
future)
- self.assertEquals(len(c), 3)
+ self.assertEqual(len(c), 3)
interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; '
'expires=%s; max-age=0' % future)
interact_netscape(c, "http://www.acme.com/", 'bar="bar"; '
'max-age=0; expires=%s' % future)
h = interact_netscape(c, "http://www.acme.com/")
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
# test expiry at end of session for cookies with no expires attribute
interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
c.clear_session_cookies()
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
self.assertTrue('spam="bar"' in h)
# XXX RFC 2965 expiry rules (some apply to V0 too)
@@ -533,7 +533,7 @@
# Default path does not include query, so is "/", not "/?spam".
self.assertIn("/", cj._cookies["example.com"])
# Cookie is sent back to the same URI.
- self.assertEquals(interact_netscape(cj, uri), value)
+ self.assertEqual(interact_netscape(cj, uri), value)
def test_escape_path(self):
cases = [
@@ -558,31 +558,31 @@
("/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded
]
for arg, result in cases:
- self.assertEquals(escape_path(arg), result)
+ self.assertEqual(escape_path(arg), result)
def test_request_path(self):
# with parameters
req = urllib.request.Request(
"http://www.example.com/rheum/rhaponticum;"
"foo=bar;sing=song?apples=pears&spam=eggs#ni")
- self.assertEquals(request_path(req),
+ self.assertEqual(request_path(req),
"/rheum/rhaponticum;foo=bar;sing=song")
# without parameters
req = urllib.request.Request(
"http://www.example.com/rheum/rhaponticum?"
"apples=pears&spam=eggs#ni")
- self.assertEquals(request_path(req), "/rheum/rhaponticum")
+ self.assertEqual(request_path(req), "/rheum/rhaponticum")
# missing final slash
req = urllib.request.Request("http://www.example.com")
- self.assertEquals(request_path(req), "/")
+ self.assertEqual(request_path(req), "/")
def test_request_port(self):
req = urllib.request.Request("http://www.acme.com:1234/",
headers={"Host": "www.acme.com:4321"})
- self.assertEquals(request_port(req), "1234")
+ self.assertEqual(request_port(req), "1234")
req = urllib.request.Request("http://www.acme.com/",
headers={"Host": "www.acme.com:4321"})
- self.assertEquals(request_port(req), DEFAULT_HTTP_PORT)
+ self.assertEqual(request_port(req), DEFAULT_HTTP_PORT)
def test_request_host(self):
# this request is illegal (RFC2616, 14.2.3)
@@ -590,15 +590,15 @@
headers={"Host": "www.acme.com:80"})
# libwww-perl wants this response, but that seems wrong (RFC 2616,
# section 5.2, point 1., and RFC 2965 section 1, paragraph 3)
- #self.assertEquals(request_host(req), "www.acme.com")
- self.assertEquals(request_host(req), "1.1.1.1")
+ #self.assertEqual(request_host(req), "www.acme.com")
+ self.assertEqual(request_host(req), "1.1.1.1")
req = urllib.request.Request("http://www.acme.com/",
headers={"Host": "irrelevant.com"})
- self.assertEquals(request_host(req), "www.acme.com")
+ self.assertEqual(request_host(req), "www.acme.com")
# port shouldn't be in request-host
req = urllib.request.Request("http://www.acme.com:2345/resource.html",
headers={"Host": "www.acme.com:5432"})
- self.assertEquals(request_host(req), "www.acme.com")
+ self.assertEqual(request_host(req), "www.acme.com")
def test_is_HDN(self):
self.assertTrue(is_HDN("foo.bar.com"))
@@ -611,14 +611,14 @@
self.assertTrue(not is_HDN("foo."))
def test_reach(self):
- self.assertEquals(reach("www.acme.com"), ".acme.com")
- self.assertEquals(reach("acme.com"), "acme.com")
- self.assertEquals(reach("acme.local"), ".local")
- self.assertEquals(reach(".local"), ".local")
- self.assertEquals(reach(".com"), ".com")
- self.assertEquals(reach("."), ".")
- self.assertEquals(reach(""), "")
- self.assertEquals(reach("192.168.0.1"), "192.168.0.1")
+ self.assertEqual(reach("www.acme.com"), ".acme.com")
+ self.assertEqual(reach("acme.com"), "acme.com")
+ self.assertEqual(reach("acme.local"), ".local")
+ self.assertEqual(reach(".local"), ".local")
+ self.assertEqual(reach(".com"), ".com")
+ self.assertEqual(reach("."), ".")
+ self.assertEqual(reach(""), "")
+ self.assertEqual(reach("192.168.0.1"), "192.168.0.1")
def test_domain_match(self):
self.assertTrue(domain_match("192.168.1.1", "192.168.1.1"))
@@ -664,7 +664,7 @@
c = CookieJar()
interact_2965(c, "http://www.nasty.com/",
'foo=bar; domain=friendly.org; Version="1"')
- self.assertEquals(len(c), 0)
+ self.assertEqual(len(c), 0)
def test_strict_domain(self):
# Cookies whose domain is a country-code tld like .co.uk should
@@ -674,11 +674,11 @@
interact_netscape(cj, "http://example.co.uk/", 'no=problemo')
interact_netscape(cj, "http://example.co.uk/",
'okey=dokey; Domain=.example.co.uk')
- self.assertEquals(len(cj), 2)
+ self.assertEqual(len(cj), 2)
for pseudo_tld in [".co.uk", ".org.za", ".tx.us", ".name.us"]:
interact_netscape(cj, "http://example.%s/" % pseudo_tld,
'spam=eggs; Domain=.co.uk')
- self.assertEquals(len(cj), 2)
+ self.assertEqual(len(cj), 2)
def test_two_component_domain_ns(self):
# Netscape: .www.bar.com, www.bar.com, .bar.com, bar.com, no domain
@@ -688,17 +688,17 @@
# two-component V0 domain is OK
interact_netscape(c, "http://foo.net/", 'ns=bar')
- self.assertEquals(len(c), 1)
- self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar")
- self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar")
+ self.assertEqual(len(c), 1)
+ self.assertEqual(c._cookies["foo.net"]["/"]["ns"].value, "bar")
+ self.assertEqual(interact_netscape(c, "http://foo.net/"), "ns=bar")
# *will* be returned to any other domain (unlike RFC 2965)...
- self.assertEquals(interact_netscape(c, "http://www.foo.net/"),
- "ns=bar")
+ self.assertEqual(interact_netscape(c, "http://www.foo.net/"),
+ "ns=bar")
# ...unless requested otherwise
pol = DefaultCookiePolicy(
strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain)
c.set_policy(pol)
- self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "")
+ self.assertEqual(interact_netscape(c, "http://www.foo.net/"), "")
# unlike RFC 2965, even explicit two-component domain is OK,
# because .foo.net matches foo.net
@@ -707,17 +707,17 @@
# even if starts with a dot -- in NS rules, .foo.net matches foo.net!
interact_netscape(c, "http://foo.net/foo/bar/",
'spam2=eggs; domain=.foo.net')
- self.assertEquals(len(c), 3)
- self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value,
- "eggs")
- self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
- "eggs")
- self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"),
- "spam2=eggs; spam1=eggs; ns=bar")
+ self.assertEqual(len(c), 3)
+ self.assertEqual(c._cookies[".foo.net"]["/foo"]["spam1"].value,
+ "eggs")
+ self.assertEqual(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
+ "eggs")
+ self.assertEqual(interact_netscape(c, "http://foo.net/foo/bar/"),
+ "spam2=eggs; spam1=eggs; ns=bar")
# top-level domain is too general
interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net')
- self.assertEquals(len(c), 3)
+ self.assertEqual(len(c), 3)
## # Netscape protocol doesn't allow non-special top level domains (such
## # as co.uk) in the domain attribute unless there are at least three
@@ -725,8 +725,8 @@
# Oh yes it does! Real implementations don't check this, and real
# cookies (of course) rely on that behaviour.
interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk')
-## self.assertEquals(len(c), 2)
- self.assertEquals(len(c), 4)
+## self.assertEqual(len(c), 2)
+ self.assertEqual(len(c), 4)
def test_two_component_domain_rfc2965(self):
pol = DefaultCookiePolicy(rfc2965=True)
@@ -734,43 +734,43 @@
# two-component V1 domain is OK
interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"')
- self.assertEquals(len(c), 1)
- self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar")
- self.assertEquals(interact_2965(c, "http://foo.net/"),
- "$Version=1; foo=bar")
+ self.assertEqual(len(c), 1)
+ self.assertEqual(c._cookies["foo.net"]["/"]["foo"].value, "bar")
+ self.assertEqual(interact_2965(c, "http://foo.net/"),
+ "$Version=1; foo=bar")
# won't be returned to any other domain (because domain was implied)
- self.assertEquals(interact_2965(c, "http://www.foo.net/"), "")
+ self.assertEqual(interact_2965(c, "http://www.foo.net/"), "")
# unless domain is given explicitly, because then it must be
# rewritten to start with a dot: foo.net --> .foo.net, which does
# not domain-match foo.net
interact_2965(c, "http://foo.net/foo",
'spam=eggs; domain=foo.net; path=/foo; Version="1"')
- self.assertEquals(len(c), 1)
- self.assertEquals(interact_2965(c, "http://foo.net/foo"),
- "$Version=1; foo=bar")
+ self.assertEqual(len(c), 1)
+ self.assertEqual(interact_2965(c, "http://foo.net/foo"),
+ "$Version=1; foo=bar")
# explicit foo.net from three-component domain www.foo.net *does* get
# set, because .foo.net domain-matches .foo.net
interact_2965(c, "http://www.foo.net/foo/",
'spam=eggs; domain=foo.net; Version="1"')
- self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value,
- "eggs")
- self.assertEquals(len(c), 2)
- self.assertEquals(interact_2965(c, "http://foo.net/foo/"),
- "$Version=1; foo=bar")
- self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"),
- '$Version=1; spam=eggs; $Domain="foo.net"')
+ self.assertEqual(c._cookies[".foo.net"]["/foo/"]["spam"].value,
+ "eggs")
+ self.assertEqual(len(c), 2)
+ self.assertEqual(interact_2965(c, "http://foo.net/foo/"),
+ "$Version=1; foo=bar")
+ self.assertEqual(interact_2965(c, "http://www.foo.net/foo/"),
+ '$Version=1; spam=eggs; $Domain="foo.net"')
# top-level domain is too general
interact_2965(c, "http://foo.net/",
'ni="ni"; domain=".net"; Version="1"')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# RFC 2965 doesn't require blocking this
interact_2965(c, "http://foo.co.uk/",
'nasty=trick; domain=.co.uk; Version="1"')
- self.assertEquals(len(c), 3)
+ self.assertEqual(len(c), 3)
def test_domain_allow(self):
c = CookieJar(policy=DefaultCookiePolicy(
@@ -781,24 +781,24 @@
headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"]
res = FakeResponse(headers, "http://acme.com/")
c.extract_cookies(res, req)
- self.assertEquals(len(c), 0)
+ self.assertEqual(len(c), 0)
req = urllib.request.Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
c.extract_cookies(res, req)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
req = urllib.request.Request("http://www.coyote.com/")
res = FakeResponse(headers, "http://www.coyote.com/")
c.extract_cookies(res, req)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
# set a cookie with non-allowed domain...
req = urllib.request.Request("http://www.coyote.com/")
res = FakeResponse(headers, "http://www.coyote.com/")
cookies = c.make_cookies(res, req)
c.set_cookie(cookies[0])
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# ... and check is doesn't get returned
c.add_cookie_header(req)
self.assertTrue(not req.has_header("Cookie"))
@@ -812,17 +812,17 @@
req = urllib.request.Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
c.extract_cookies(res, req)
- self.assertEquals(len(c), 0)
+ self.assertEqual(len(c), 0)
p = pol.set_blocked_domains(["acme.com"])
c.extract_cookies(res, req)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
c.clear()
req = urllib.request.Request("http://www.roadrunner.net/")
res = FakeResponse(headers, "http://www.roadrunner.net/")
c.extract_cookies(res, req)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
req = urllib.request.Request("http://www.roadrunner.net/")
c.add_cookie_header(req)
self.assertTrue((req.has_header("Cookie") and
@@ -831,14 +831,14 @@
c.clear()
pol.set_blocked_domains([".acme.com"])
c.extract_cookies(res, req)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
# set a cookie with blocked domain...
req = urllib.request.Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
cookies = c.make_cookies(res, req)
c.set_cookie(cookies[0])
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# ... and check is doesn't get returned
c.add_cookie_header(req)
self.assertTrue(not req.has_header("Cookie"))
@@ -870,7 +870,7 @@
c = CookieJar(policy=DefaultCookiePolicy(rfc2965=True))
interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1')
h = interact_2965(c, "http://www.acme.com/")
- self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r')
+ self.assertEqual(h, r'$Version=1; foo=\\b\"a\"r')
def test_missing_final_slash(self):
# Missing slash from request URL's abs_path should be assumed present.
@@ -878,7 +878,7 @@
c = CookieJar(DefaultCookiePolicy(rfc2965=True))
interact_2965(c, url, "foo=bar; Version=1")
req = urllib.request.Request(url)
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
c.add_cookie_header(req)
self.assertTrue(req.has_header("Cookie"))
@@ -990,31 +990,31 @@
i = 0
for c in cs:
self.assertTrue(isinstance(c, Cookie))
- self.assertEquals(c.version, versions[i])
- self.assertEquals(c.name, names[i])
- self.assertEquals(c.domain, domains[i])
- self.assertEquals(c.path, paths[i])
+ self.assertEqual(c.version, versions[i])
+ self.assertEqual(c.name, names[i])
+ self.assertEqual(c.domain, domains[i])
+ self.assertEqual(c.path, paths[i])
i = i + 1
def test_parse_ns_headers(self):
# missing domain value (invalid cookie)
- self.assertEquals(
+ self.assertEqual(
parse_ns_headers(["foo=bar; path=/; domain"]),
[[("foo", "bar"),
("path", "/"), ("domain", None), ("version", "0")]]
)
# invalid expires value
- self.assertEquals(
+ self.assertEqual(
parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]),
[[("foo", "bar"), ("expires", None), ("version", "0")]]
)
# missing cookie value (valid cookie)
- self.assertEquals(
+ self.assertEqual(
parse_ns_headers(["foo"]),
[[("foo", None), ("version", "0")]]
)
# shouldn't add version if header is empty
- self.assertEquals(parse_ns_headers([""]), [])
+ self.assertEqual(parse_ns_headers([""]), [])
def test_bad_cookie_header(self):
@@ -1036,7 +1036,7 @@
]:
c = cookiejar_from_cookie_headers(headers)
# these bad cookies shouldn't be set
- self.assertEquals(len(c), 0)
+ self.assertEqual(len(c), 0)
# cookie with invalid expires is treated as session cookie
headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"]
@@ -1175,8 +1175,8 @@
req = urllib.request.Request("http://www.acme.com/")
c.add_cookie_header(req)
- self.assertEquals(req.get_header("Cookie"),
- "PART_NUMBER=ROCKET_LAUNCHER_0001")
+ self.assertEqual(req.get_header("Cookie"),
+ "PART_NUMBER=ROCKET_LAUNCHER_0001")
headers.append(
"Set-Cookie: PART_NUMBER=RIDING_ROCKET_0023; path=/ammo")
@@ -1374,40 +1374,40 @@
# legal domain
cookie = interact_2965(c, "http://www.acme.com",
'ping=pong; domain="acme.com"; version=1')
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
# illegal domain (host prefix "www.a" contains a dot)
cookie = interact_2965(c, "http://www.a.acme.com",
'whiz=bang; domain="acme.com"; version=1')
- self.assertEquals(len(c), 1)
+ self.assertEqual(len(c), 1)
# legal domain
cookie = interact_2965(c, "http://www.a.acme.com",
'wow=flutter; domain=".a.acme.com"; version=1')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# can't partially match an IP-address
cookie = interact_2965(c, "http://125.125.125.125",
'zzzz=ping; domain="125.125.125"; version=1')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# illegal path (must be prefix of request path)
cookie = interact_2965(c, "http://www.sol.no",
'blah=rhubarb; domain=".sol.no"; path="/foo"; '
'version=1')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
# legal path
cookie = interact_2965(c, "http://www.sol.no/foo/bar",
'bing=bong; domain=".sol.no"; path="/foo"; '
'version=1')
- self.assertEquals(len(c), 3)
+ self.assertEqual(len(c), 3)
# illegal port (request-port not in list)
cookie = interact_2965(c, "http://www.sol.no",
'whiz=ffft; domain=".sol.no"; port="90,100"; '
'version=1')
- self.assertEquals(len(c), 3)
+ self.assertEqual(len(c), 3)
# legal port
cookie = interact_2965(
@@ -1415,13 +1415,13 @@
r'bang=wallop; version=1; domain=".sol.no"; '
r'port="90,100, 80,8080"; '
r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
- self.assertEquals(len(c), 4)
+ self.assertEqual(len(c), 4)
# port attribute without any value (current port)
cookie = interact_2965(c, "http://www.sol.no",
'foo9=bar; version=1; domain=".sol.no"; port; '
'max-age=100;')
- self.assertEquals(len(c), 5)
+ self.assertEqual(len(c), 5)
# encoded path
# LWP has this test, but unescaping allowed path characters seems
@@ -1432,7 +1432,7 @@
# character:
cookie = interact_2965(c, "http://www.sol.no/<oo/",
r'foo8=bar; version=1; path="/%3coo"')
- self.assertEquals(len(c), 6)
+ self.assertEqual(len(c), 6)
# save and restore
filename = test.support.TESTFN
@@ -1447,7 +1447,7 @@
try: os.unlink(filename)
except OSError: pass
- self.assertEquals(old, repr(c))
+ self.assertEqual(old, repr(c))
def test_url_encoding(self):
# Try some URL encodings of the PATHs.
@@ -1504,11 +1504,11 @@
return new_c
new_c = save_and_restore(c, True)
- self.assertEquals(len(new_c), 6) # none discarded
+ self.assertEqual(len(new_c), 6) # none discarded
self.assertTrue("name='foo1', value='bar'" in repr(new_c))
new_c = save_and_restore(c, False)
- self.assertEquals(len(new_c), 4) # 2 of them discarded on save
+ self.assertEqual(len(new_c), 4) # 2 of them discarded on save
self.assertTrue("name='foo1', value='bar'" in repr(new_c))
def test_netscape_misc(self):
@@ -1553,12 +1553,12 @@
interact_netscape(c, "http://example/", "foo1=bar")
cookie = interact_netscape(c, "http://example/",
'foo2=bar; domain=.local')
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
self.assertTrue("foo1=bar" in cookie)
cookie = interact_netscape(c, "http://example/")
self.assertTrue("foo2=bar" in cookie)
- self.assertEquals(len(c), 2)
+ self.assertEqual(len(c), 2)
def test_empty_path(self):
# Test for empty path
@@ -1579,17 +1579,17 @@
req = urllib.request.Request("http://www.ants.com/")
c.add_cookie_header(req)
- self.assertEquals(req.get_header("Cookie"),
- "JSESSIONID=ABCDERANDOM123")
- self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
+ self.assertEqual(req.get_header("Cookie"),
+ "JSESSIONID=ABCDERANDOM123")
+ self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
# missing path in the request URI
req = urllib.request.Request("http://www.ants.com:8080")
c.add_cookie_header(req)
- self.assertEquals(req.get_header("Cookie"),
- "JSESSIONID=ABCDERANDOM123")
- self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
+ self.assertEqual(req.get_header("Cookie"),
+ "JSESSIONID=ABCDERANDOM123")
+ self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
def test_session_cookies(self):
year_plus_one = time.localtime()[0] + 1
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index ee28316..4c02d90 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -208,13 +208,13 @@
sock = FakeSocket(None)
conn.sock = sock
conn.send(expected)
- self.assertEquals(expected, sock.data)
+ self.assertEqual(expected, sock.data)
sock.data = b''
conn.send(array.array('b', expected))
- self.assertEquals(expected, sock.data)
+ self.assertEqual(expected, sock.data)
sock.data = b''
conn.send(io.BytesIO(expected))
- self.assertEquals(expected, sock.data)
+ self.assertEqual(expected, sock.data)
def test_chunked(self):
chunked_start = (
@@ -228,7 +228,7 @@
sock = FakeSocket(chunked_start + '0\r\n')
resp = client.HTTPResponse(sock, method="GET")
resp.begin()
- self.assertEquals(resp.read(), b'hello world')
+ self.assertEqual(resp.read(), b'hello world')
resp.close()
for x in ('', 'foo\r\n'):
@@ -238,7 +238,7 @@
try:
resp.read()
except client.IncompleteRead as i:
- self.assertEquals(i.partial, b'hello world')
+ self.assertEqual(i.partial, b'hello world')
self.assertEqual(repr(i),'IncompleteRead(11 bytes read)')
self.assertEqual(str(i),'IncompleteRead(11 bytes read)')
else:
@@ -258,9 +258,9 @@
sock = FakeSocket(chunked_start + '0\r\n')
resp = client.HTTPResponse(sock, method="HEAD")
resp.begin()
- self.assertEquals(resp.read(), b'')
- self.assertEquals(resp.status, 200)
- self.assertEquals(resp.reason, 'OK')
+ self.assertEqual(resp.read(), b'')
+ self.assertEqual(resp.status, 200)
+ self.assertEqual(resp.reason, 'OK')
self.assertTrue(resp.isclosed())
def test_negative_content_length(self):
@@ -268,7 +268,7 @@
'HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\nHello\r\n')
resp = client.HTTPResponse(sock, method="GET")
resp.begin()
- self.assertEquals(resp.read(), b'Hello\r\n')
+ self.assertEqual(resp.read(), b'Hello\r\n')
resp.close()
def test_incomplete_read(self):
@@ -278,7 +278,7 @@
try:
resp.read()
except client.IncompleteRead as i:
- self.assertEquals(i.partial, b'Hello\r\n')
+ self.assertEqual(i.partial, b'Hello\r\n')
self.assertEqual(repr(i),
"IncompleteRead(7 bytes read, 3 more expected)")
self.assertEqual(str(i),
@@ -305,7 +305,7 @@
class OfflineTest(TestCase):
def test_responses(self):
- self.assertEquals(client.responses[client.NOT_FOUND], "Not Found")
+ self.assertEqual(client.responses[client.NOT_FOUND], "Not Found")
class TimeoutTest(TestCase):
PORT = None
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
index cd6f1cf..6c849a1 100644
--- a/Lib/test/test_httpservers.py
+++ b/Lib/test/test_httpservers.py
@@ -173,42 +173,42 @@
def test_command(self):
self.con.request('GET', '/')
res = self.con.getresponse()
- self.assertEquals(res.status, 501)
+ self.assertEqual(res.status, 501)
def test_request_line_trimming(self):
self.con._http_vsn_str = 'HTTP/1.1\n'
self.con.putrequest('GET', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 501)
+ self.assertEqual(res.status, 501)
def test_version_bogus(self):
self.con._http_vsn_str = 'FUBAR'
self.con.putrequest('GET', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 400)
+ self.assertEqual(res.status, 400)
def test_version_digits(self):
self.con._http_vsn_str = 'HTTP/9.9.9'
self.con.putrequest('GET', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 400)
+ self.assertEqual(res.status, 400)
def test_version_none_get(self):
self.con._http_vsn_str = ''
self.con.putrequest('GET', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 501)
+ self.assertEqual(res.status, 501)
def test_version_none(self):
self.con._http_vsn_str = ''
self.con.putrequest('PUT', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 400)
+ self.assertEqual(res.status, 400)
def test_version_invalid(self):
self.con._http_vsn = 99
@@ -216,21 +216,21 @@
self.con.putrequest('GET', '/')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 505)
+ self.assertEqual(res.status, 505)
def test_send_blank(self):
self.con._http_vsn_str = ''
self.con.putrequest('', '')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 400)
+ self.assertEqual(res.status, 400)
def test_header_close(self):
self.con.putrequest('GET', '/')
self.con.putheader('Connection', 'close')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 501)
+ self.assertEqual(res.status, 501)
def test_head_keep_alive(self):
self.con._http_vsn_str = 'HTTP/1.1'
@@ -238,28 +238,28 @@
self.con.putheader('Connection', 'keep-alive')
self.con.endheaders()
res = self.con.getresponse()
- self.assertEquals(res.status, 501)
+ self.assertEqual(res.status, 501)
def test_handler(self):
self.con.request('TEST', '/')
res = self.con.getresponse()
- self.assertEquals(res.status, 204)
+ self.assertEqual(res.status, 204)
def test_return_header_keep_alive(self):
self.con.request('KEEP', '/')
res = self.con.getresponse()
- self.assertEquals(res.getheader('Connection'), 'keep-alive')
+ self.assertEqual(res.getheader('Connection'), 'keep-alive')
self.con.request('TEST', '/')
def test_internal_key_error(self):
self.con.request('KEYERROR', '/')
res = self.con.getresponse()
- self.assertEquals(res.status, 999)
+ self.assertEqual(res.status, 999)
def test_return_custom_status(self):
self.con.request('CUSTOM', '/')
res = self.con.getresponse()
- self.assertEquals(res.status, 999)
+ self.assertEqual(res.status, 999)
class SimpleHTTPServerTestCase(BaseTestCase):
@@ -291,7 +291,7 @@
def check_status_and_reason(self, response, status, data=None):
body = response.read()
self.assertTrue(response)
- self.assertEquals(response.status, status)
+ self.assertEqual(response.status, status)
self.assertTrue(response.reason != None)
if data:
self.assertEqual(data, body)
@@ -435,13 +435,13 @@
server._url_collapse_path_split, path)
else:
actual = server._url_collapse_path_split(path)
- self.assertEquals(expected, actual,
- msg='path = %r\nGot: %r\nWanted: %r' % (
- path, actual, expected))
+ self.assertEqual(expected, actual,
+ msg='path = %r\nGot: %r\nWanted: %r' % (
+ path, actual, expected))
def test_headers_and_content(self):
res = self.request('/cgi-bin/file1.py')
- self.assertEquals((b'Hello World\n', 'text/html', 200), \
+ self.assertEqual((b'Hello World\n', 'text/html', 200), \
(res.read(), res.getheader('Content-type'), res.status))
def test_post(self):
@@ -450,24 +450,24 @@
headers = {'Content-type' : 'application/x-www-form-urlencoded'}
res = self.request('/cgi-bin/file2.py', 'POST', params, headers)
- self.assertEquals(res.read(), b'1, python, 123456\n')
+ self.assertEqual(res.read(), b'1, python, 123456\n')
def test_invaliduri(self):
res = self.request('/cgi-bin/invalid')
res.read()
- self.assertEquals(res.status, 404)
+ self.assertEqual(res.status, 404)
def test_authorization(self):
headers = {b'Authorization' : b'Basic ' +
base64.b64encode(b'username:pass')}
res = self.request('/cgi-bin/file1.py', 'GET', headers=headers)
- self.assertEquals((b'Hello World\n', 'text/html', 200), \
+ self.assertEqual((b'Hello World\n', 'text/html', 200), \
(res.read(), res.getheader('Content-type'), res.status))
def test_no_leading_slash(self):
# http://bugs.python.org/issue2254
res = self.request('cgi-bin/file1.py')
- self.assertEquals((b'Hello World\n', 'text/html', 200),
+ self.assertEqual((b'Hello World\n', 'text/html', 200),
(res.read(), res.getheader('Content-type'), res.status))
def test_os_environ_is_not_altered(self):
diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py
index 58e432a..1ab28c5 100644
--- a/Lib/test/test_imaplib.py
+++ b/Lib/test/test_imaplib.py
@@ -115,7 +115,7 @@
if verbose: print("creating server")
server = MyServer(addr, hdlr)
- self.assertEquals(server.server_address, server.socket.getsockname())
+ self.assertEqual(server.server_address, server.socket.getsockname())
if verbose:
print("server created")
diff --git a/Lib/test/test_imp.py b/Lib/test/test_imp.py
index d66d40e..1671e48 100644
--- a/Lib/test/test_imp.py
+++ b/Lib/test/test_imp.py
@@ -70,7 +70,7 @@
file.write("# coding: cp1252\nu = 'test.test_imp'\n")
file, filename, info = imp.find_module(temp_mod_name)
file.close()
- self.assertEquals(file.encoding, 'cp1252')
+ self.assertEqual(file.encoding, 'cp1252')
finally:
del sys.path[0]
support.unlink(temp_mod_name + '.py')
diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py
index adf64e7..e50cd53 100644
--- a/Lib/test/test_import.py
+++ b/Lib/test/test_import.py
@@ -111,8 +111,8 @@
if not os.path.exists(fn): raise TestFailed("__import__ did "
"not result in creation of either a .pyc or .pyo file")
s = os.stat(fn)
- self.assertEquals(stat.S_IMODE(s.st_mode),
- stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
+ self.assertEqual(stat.S_IMODE(s.st_mode),
+ stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
finally:
os.umask(oldmask)
remove_files(TESTFN)
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
index b926d9a..34e0a9a 100644
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -382,8 +382,8 @@
self.assertRaises(IOError, inspect.findsource, co)
self.assertRaises(IOError, inspect.getsource, co)
linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)
- self.assertEquals(inspect.findsource(co), (lines,0))
- self.assertEquals(inspect.getsource(co), lines[0])
+ self.assertEqual(inspect.findsource(co), (lines,0))
+ self.assertEqual(inspect.getsource(co), lines[0])
# Helper for testing classify_class_attrs.
def attrs_wo_objs(cls):
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
index d56e1f0..f7d2318 100644
--- a/Lib/test/test_int.py
+++ b/Lib/test/test_int.py
@@ -293,7 +293,7 @@
try:
int(TruncReturnsNonIntegral())
except TypeError as e:
- self.assertEquals(str(e),
+ self.assertEqual(str(e),
"__trunc__ returned non-Integral"
" (type NonIntegral)")
else:
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index fe361be..acf90df 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -598,7 +598,7 @@
rawio = self.MockRawIO()
bufio = self.tp(rawio)
- self.assertEquals(42, bufio.fileno())
+ self.assertEqual(42, bufio.fileno())
def test_no_fileno(self):
# XXX will we always have fileno() function? If so, kill
@@ -703,36 +703,36 @@
bufio.__init__(rawio)
bufio.__init__(rawio, buffer_size=1024)
bufio.__init__(rawio, buffer_size=16)
- self.assertEquals(b"abc", bufio.read())
+ self.assertEqual(b"abc", bufio.read())
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
rawio = self.MockRawIO([b"abc"])
bufio.__init__(rawio)
- self.assertEquals(b"abc", bufio.read())
+ self.assertEqual(b"abc", bufio.read())
def test_read(self):
for arg in (None, 7):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read(arg))
+ self.assertEqual(b"abcdefg", bufio.read(arg))
# Invalid args
self.assertRaises(ValueError, bufio.read, -2)
def test_read1(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"a", bufio.read(1))
- self.assertEquals(b"b", bufio.read1(1))
- self.assertEquals(rawio._reads, 1)
- self.assertEquals(b"c", bufio.read1(100))
- self.assertEquals(rawio._reads, 1)
- self.assertEquals(b"d", bufio.read1(100))
- self.assertEquals(rawio._reads, 2)
- self.assertEquals(b"efg", bufio.read1(100))
- self.assertEquals(rawio._reads, 3)
- self.assertEquals(b"", bufio.read1(100))
- self.assertEquals(rawio._reads, 4)
+ self.assertEqual(b"a", bufio.read(1))
+ self.assertEqual(b"b", bufio.read1(1))
+ self.assertEqual(rawio._reads, 1)
+ self.assertEqual(b"c", bufio.read1(100))
+ self.assertEqual(rawio._reads, 1)
+ self.assertEqual(b"d", bufio.read1(100))
+ self.assertEqual(rawio._reads, 2)
+ self.assertEqual(b"efg", bufio.read1(100))
+ self.assertEqual(rawio._reads, 3)
+ self.assertEqual(b"", bufio.read1(100))
+ self.assertEqual(rawio._reads, 4)
# Invalid args
self.assertRaises(ValueError, bufio.read1, -1)
@@ -740,24 +740,24 @@
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
b = bytearray(2)
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"ab")
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"cd")
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"ef")
- self.assertEquals(bufio.readinto(b), 1)
- self.assertEquals(b, b"gf")
- self.assertEquals(bufio.readinto(b), 0)
- self.assertEquals(b, b"gf")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"ab")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"cd")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"ef")
+ self.assertEqual(bufio.readinto(b), 1)
+ self.assertEqual(b, b"gf")
+ self.assertEqual(bufio.readinto(b), 0)
+ self.assertEqual(b, b"gf")
def test_readlines(self):
def bufio():
rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef"))
return self.tp(rawio)
- self.assertEquals(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
- self.assertEquals(bufio().readlines(5), [b"abc\n", b"d\n"])
- self.assertEquals(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
+ self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
+ self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"])
+ self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
def test_buffering(self):
data = b"abcdefghi"
@@ -774,34 +774,34 @@
bufio = self.tp(rawio, buffer_size=bufsize)
pos = 0
for nbytes in buf_read_sizes:
- self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes])
+ self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes])
pos += nbytes
# this is mildly implementation-dependent
- self.assertEquals(rawio.read_history, raw_read_sizes)
+ self.assertEqual(rawio.read_history, raw_read_sizes)
def test_read_non_blocking(self):
# Inject some None's in there to simulate EWOULDBLOCK
rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None))
bufio = self.tp(rawio)
- self.assertEquals(b"abcd", bufio.read(6))
- self.assertEquals(b"e", bufio.read(1))
- self.assertEquals(b"fg", bufio.read())
- self.assertEquals(b"", bufio.peek(1))
+ self.assertEqual(b"abcd", bufio.read(6))
+ self.assertEqual(b"e", bufio.read(1))
+ self.assertEqual(b"fg", bufio.read())
+ self.assertEqual(b"", bufio.peek(1))
self.assertTrue(None is bufio.read())
- self.assertEquals(b"", bufio.read())
+ self.assertEqual(b"", bufio.read())
def test_read_past_eof(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read(9000))
+ self.assertEqual(b"abcdefg", bufio.read(9000))
def test_read_all(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read())
+ self.assertEqual(b"abcdefg", bufio.read())
@support.requires_resource('cpu')
def test_threads(self):
@@ -927,15 +927,15 @@
bufio.__init__(rawio)
bufio.__init__(rawio, buffer_size=1024)
bufio.__init__(rawio, buffer_size=16)
- self.assertEquals(3, bufio.write(b"abc"))
+ self.assertEqual(3, bufio.write(b"abc"))
bufio.flush()
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
bufio.__init__(rawio)
- self.assertEquals(3, bufio.write(b"ghi"))
+ self.assertEqual(3, bufio.write(b"ghi"))
bufio.flush()
- self.assertEquals(b"".join(rawio._write_stack), b"abcghi")
+ self.assertEqual(b"".join(rawio._write_stack), b"abcghi")
def test_detach_flush(self):
raw = self.MockRawIO()
@@ -977,11 +977,11 @@
sizes = gen_sizes()
while n < len(contents):
size = min(next(sizes), len(contents) - n)
- self.assertEquals(bufio.write(contents[n:n+size]), size)
+ self.assertEqual(bufio.write(contents[n:n+size]), size)
intermediate_func(bufio)
n += size
bufio.flush()
- self.assertEquals(contents, b"".join(writer._write_stack))
+ self.assertEqual(contents, b"".join(writer._write_stack))
def test_writes(self):
self.check_writes(lambda bufio: None)
@@ -1010,11 +1010,11 @@
raw = self.MockNonBlockWriterIO()
bufio = self.tp(raw, 8)
- self.assertEquals(bufio.write(b"abcd"), 4)
- self.assertEquals(bufio.write(b"efghi"), 5)
+ self.assertEqual(bufio.write(b"abcd"), 4)
+ self.assertEqual(bufio.write(b"efghi"), 5)
# 1 byte will be written, the rest will be buffered
raw.block_on(b"k")
- self.assertEquals(bufio.write(b"jklmn"), 5)
+ self.assertEqual(bufio.write(b"jklmn"), 5)
# 8 bytes will be written, 8 will be buffered and the rest will be lost
raw.block_on(b"0")
@@ -1024,11 +1024,11 @@
written = e.characters_written
else:
self.fail("BlockingIOError should have been raised")
- self.assertEquals(written, 16)
- self.assertEquals(raw.pop_written(),
+ self.assertEqual(written, 16)
+ self.assertEqual(raw.pop_written(),
b"abcdefghijklmnopqrwxyz")
- self.assertEquals(bufio.write(b"ABCDEFGHI"), 9)
+ self.assertEqual(bufio.write(b"ABCDEFGHI"), 9)
s = raw.pop_written()
# Previously buffered bytes were flushed
self.assertTrue(s.startswith(b"01234567A"), s)
@@ -1051,7 +1051,7 @@
bufio = self.tp(writer, 8)
bufio.write(b"abc")
bufio.flush()
- self.assertEquals(b"abc", writer._write_stack[0])
+ self.assertEqual(b"abc", writer._write_stack[0])
def test_destructor(self):
writer = self.MockRawIO()
@@ -1059,7 +1059,7 @@
bufio.write(b"abc")
del bufio
support.gc_collect()
- self.assertEquals(b"abc", writer._write_stack[0])
+ self.assertEqual(b"abc", writer._write_stack[0])
def test_truncate(self):
# Truncate implicitly flushes the buffer.
@@ -1117,7 +1117,7 @@
with self.open(support.TESTFN, "rb") as f:
s = f.read()
for i in range(256):
- self.assertEquals(s.count(bytes([i])), N)
+ self.assertEqual(s.count(bytes([i])), N)
finally:
support.unlink(support.TESTFN)
@@ -1328,45 +1328,45 @@
rw.write(b"eee")
self.assertFalse(raw._write_stack) # Buffer writes
self.assertEqual(b"ghjk", rw.read())
- self.assertEquals(b"dddeee", raw._write_stack[0])
+ self.assertEqual(b"dddeee", raw._write_stack[0])
def test_seek_and_tell(self):
raw = self.BytesIO(b"asdfghjkl")
rw = self.tp(raw)
- self.assertEquals(b"as", rw.read(2))
- self.assertEquals(2, rw.tell())
+ self.assertEqual(b"as", rw.read(2))
+ self.assertEqual(2, rw.tell())
rw.seek(0, 0)
- self.assertEquals(b"asdf", rw.read(4))
+ self.assertEqual(b"asdf", rw.read(4))
rw.write(b"asdf")
rw.seek(0, 0)
- self.assertEquals(b"asdfasdfl", rw.read())
- self.assertEquals(9, rw.tell())
+ self.assertEqual(b"asdfasdfl", rw.read())
+ self.assertEqual(9, rw.tell())
rw.seek(-4, 2)
- self.assertEquals(5, rw.tell())
+ self.assertEqual(5, rw.tell())
rw.seek(2, 1)
- self.assertEquals(7, rw.tell())
- self.assertEquals(b"fl", rw.read(11))
+ self.assertEqual(7, rw.tell())
+ self.assertEqual(b"fl", rw.read(11))
self.assertRaises(TypeError, rw.seek, 0.0)
def check_flush_and_read(self, read_func):
raw = self.BytesIO(b"abcdefghi")
bufio = self.tp(raw)
- self.assertEquals(b"ab", read_func(bufio, 2))
+ self.assertEqual(b"ab", read_func(bufio, 2))
bufio.write(b"12")
- self.assertEquals(b"ef", read_func(bufio, 2))
- self.assertEquals(6, bufio.tell())
+ self.assertEqual(b"ef", read_func(bufio, 2))
+ self.assertEqual(6, bufio.tell())
bufio.flush()
- self.assertEquals(6, bufio.tell())
- self.assertEquals(b"ghi", read_func(bufio))
+ self.assertEqual(6, bufio.tell())
+ self.assertEqual(b"ghi", read_func(bufio))
raw.seek(0, 0)
raw.write(b"XYZ")
# flush() resets the read buffer
bufio.flush()
bufio.seek(0, 0)
- self.assertEquals(b"XYZ", read_func(bufio, 3))
+ self.assertEqual(b"XYZ", read_func(bufio, 3))
def test_flush_and_read(self):
self.check_flush_and_read(lambda bufio, *args: bufio.read(*args))
@@ -1398,8 +1398,8 @@
bufio.write(b"45")
bufio.flush()
bufio.seek(0, 0)
- self.assertEquals(b"12345fghi", raw.getvalue())
- self.assertEquals(b"12345fghi", bufio.read())
+ self.assertEqual(b"12345fghi", raw.getvalue())
+ self.assertEqual(b"12345fghi", bufio.read())
def test_threads(self):
BufferedReaderTest.test_threads(self)
@@ -1624,12 +1624,12 @@
# Try a few one-shot test cases.
for input, eof, output in self.test_cases:
d = StatefulIncrementalDecoder()
- self.assertEquals(d.decode(input, eof), output)
+ self.assertEqual(d.decode(input, eof), output)
# Also test an unfinished decode, followed by forcing EOF.
d = StatefulIncrementalDecoder()
- self.assertEquals(d.decode(b'oiabcd'), '')
- self.assertEquals(d.decode(b'', 1), 'abcd.')
+ self.assertEqual(d.decode(b'oiabcd'), '')
+ self.assertEqual(d.decode(b'', 1), 'abcd.')
class TextIOWrapperTest(unittest.TestCase):
@@ -1646,12 +1646,12 @@
b = self.BufferedReader(r, 1000)
t = self.TextIOWrapper(b)
t.__init__(b, encoding="latin1", newline="\r\n")
- self.assertEquals(t.encoding, "latin1")
- self.assertEquals(t.line_buffering, False)
+ self.assertEqual(t.encoding, "latin1")
+ self.assertEqual(t.line_buffering, False)
t.__init__(b, encoding="utf8", line_buffering=True)
- self.assertEquals(t.encoding, "utf8")
- self.assertEquals(t.line_buffering, True)
- self.assertEquals("\xe9\n", t.readline())
+ self.assertEqual(t.encoding, "utf8")
+ self.assertEqual(t.line_buffering, True)
+ self.assertEqual("\xe9\n", t.readline())
self.assertRaises(TypeError, t.__init__, b, newline=42)
self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
@@ -1687,11 +1687,11 @@
b = self.BufferedWriter(r, 1000)
t = self.TextIOWrapper(b, newline="\n", line_buffering=True)
t.write("X")
- self.assertEquals(r.getvalue(), b"") # No flush happened
+ self.assertEqual(r.getvalue(), b"") # No flush happened
t.write("Y\nZ")
- self.assertEquals(r.getvalue(), b"XY\nZ") # All got flushed
+ self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed
t.write("A\rB")
- self.assertEquals(r.getvalue(), b"XY\nZA\rB")
+ self.assertEqual(r.getvalue(), b"XY\nZA\rB")
def test_encoding(self):
# Check the encoding attribute is always set, and valid
@@ -1714,11 +1714,11 @@
# (3) ignore
b = self.BytesIO(b"abc\n\xff\n")
t = self.TextIOWrapper(b, encoding="ascii", errors="ignore")
- self.assertEquals(t.read(), "abc\n\n")
+ self.assertEqual(t.read(), "abc\n\n")
# (4) replace
b = self.BytesIO(b"abc\n\xff\n")
t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
- self.assertEquals(t.read(), "abc\n\ufffd\n")
+ self.assertEqual(t.read(), "abc\n\ufffd\n")
def test_encoding_errors_writing(self):
# (1) default
@@ -1735,14 +1735,14 @@
newline="\n")
t.write("abc\xffdef\n")
t.flush()
- self.assertEquals(b.getvalue(), b"abcdef\n")
+ self.assertEqual(b.getvalue(), b"abcdef\n")
# (4) replace
b = self.BytesIO()
t = self.TextIOWrapper(b, encoding="ascii", errors="replace",
newline="\n")
t.write("abc\xffdef\n")
t.flush()
- self.assertEquals(b.getvalue(), b"abc?def\n")
+ self.assertEqual(b.getvalue(), b"abc?def\n")
def test_newlines(self):
input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
@@ -1777,14 +1777,14 @@
c2 = textio.read(2)
if c2 == '':
break
- self.assertEquals(len(c2), 2)
+ self.assertEqual(len(c2), 2)
got_lines.append(c2 + textio.readline())
else:
got_lines = list(textio)
for got_line, exp_line in zip(got_lines, exp_lines):
- self.assertEquals(got_line, exp_line)
- self.assertEquals(len(got_lines), len(exp_lines))
+ self.assertEqual(got_line, exp_line)
+ self.assertEqual(len(got_lines), len(exp_lines))
def test_newlines_input(self):
testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
@@ -1798,9 +1798,9 @@
]:
buf = self.BytesIO(testdata)
txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline)
- self.assertEquals(txt.readlines(), expected)
+ self.assertEqual(txt.readlines(), expected)
txt.seek(0)
- self.assertEquals(txt.read(), "".join(expected))
+ self.assertEqual(txt.read(), "".join(expected))
def test_newlines_output(self):
testdict = {
@@ -1817,8 +1817,8 @@
txt.write("BB\nCCC\n")
txt.write("X\rY\r\nZ")
txt.flush()
- self.assertEquals(buf.closed, False)
- self.assertEquals(buf.getvalue(), expected)
+ self.assertEqual(buf.closed, False)
+ self.assertEqual(buf.getvalue(), expected)
def test_destructor(self):
l = []
@@ -1832,7 +1832,7 @@
t.write("abc")
del t
support.gc_collect()
- self.assertEquals([b"abc"], l)
+ self.assertEqual([b"abc"], l)
def test_override_destructor(self):
record = []
@@ -1879,26 +1879,26 @@
for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le":
f = self.open(support.TESTFN, "w+", encoding=enc)
f._CHUNK_SIZE = chunksize
- self.assertEquals(f.write("abc"), 3)
+ self.assertEqual(f.write("abc"), 3)
f.close()
f = self.open(support.TESTFN, "r+", encoding=enc)
f._CHUNK_SIZE = chunksize
- self.assertEquals(f.tell(), 0)
- self.assertEquals(f.read(), "abc")
+ self.assertEqual(f.tell(), 0)
+ self.assertEqual(f.read(), "abc")
cookie = f.tell()
- self.assertEquals(f.seek(0), 0)
- self.assertEquals(f.read(None), "abc")
+ self.assertEqual(f.seek(0), 0)
+ self.assertEqual(f.read(None), "abc")
f.seek(0)
- self.assertEquals(f.read(2), "ab")
- self.assertEquals(f.read(1), "c")
- self.assertEquals(f.read(1), "")
- self.assertEquals(f.read(), "")
- self.assertEquals(f.tell(), cookie)
- self.assertEquals(f.seek(0), 0)
- self.assertEquals(f.seek(0, 2), cookie)
- self.assertEquals(f.write("def"), 3)
- self.assertEquals(f.seek(cookie), cookie)
- self.assertEquals(f.read(), "def")
+ self.assertEqual(f.read(2), "ab")
+ self.assertEqual(f.read(1), "c")
+ self.assertEqual(f.read(1), "")
+ self.assertEqual(f.read(), "")
+ self.assertEqual(f.tell(), cookie)
+ self.assertEqual(f.seek(0), 0)
+ self.assertEqual(f.seek(0, 2), cookie)
+ self.assertEqual(f.write("def"), 3)
+ self.assertEqual(f.seek(cookie), cookie)
+ self.assertEqual(f.read(), "def")
if enc.startswith("utf"):
self.multi_line_test(f, enc)
f.close()
@@ -1923,7 +1923,7 @@
if not line:
break
rlines.append((pos, line))
- self.assertEquals(rlines, wlines)
+ self.assertEqual(rlines, wlines)
def test_telling(self):
f = self.open(support.TESTFN, "w+", encoding="utf8")
@@ -1933,16 +1933,16 @@
f.write("\xff\n")
p2 = f.tell()
f.seek(0)
- self.assertEquals(f.tell(), p0)
- self.assertEquals(f.readline(), "\xff\n")
- self.assertEquals(f.tell(), p1)
- self.assertEquals(f.readline(), "\xff\n")
- self.assertEquals(f.tell(), p2)
+ self.assertEqual(f.tell(), p0)
+ self.assertEqual(f.readline(), "\xff\n")
+ self.assertEqual(f.tell(), p1)
+ self.assertEqual(f.readline(), "\xff\n")
+ self.assertEqual(f.tell(), p2)
f.seek(0)
for line in f:
- self.assertEquals(line, "\xff\n")
+ self.assertEqual(line, "\xff\n")
self.assertRaises(IOError, f.tell)
- self.assertEquals(f.tell(), p2)
+ self.assertEqual(f.tell(), p2)
f.close()
def test_seeking(self):
@@ -1950,7 +1950,7 @@
prefix_size = chunk_size - 2
u_prefix = "a" * prefix_size
prefix = bytes(u_prefix.encode("utf-8"))
- self.assertEquals(len(u_prefix), len(prefix))
+ self.assertEqual(len(u_prefix), len(prefix))
u_suffix = "\u8888\n"
suffix = bytes(u_suffix.encode("utf-8"))
line = prefix + suffix
@@ -1959,9 +1959,9 @@
f.close()
f = self.open(support.TESTFN, "r", encoding="utf-8")
s = f.read(prefix_size)
- self.assertEquals(s, str(prefix, "ascii"))
- self.assertEquals(f.tell(), prefix_size)
- self.assertEquals(f.readline(), u_suffix)
+ self.assertEqual(s, str(prefix, "ascii"))
+ self.assertEqual(f.tell(), prefix_size)
+ self.assertEqual(f.readline(), u_suffix)
def test_seeking_too(self):
# Regression test for a specific bug
@@ -1994,11 +1994,11 @@
for i in range(min_pos, len(decoded) + 1): # seek positions
for j in [1, 5, len(decoded) - i]: # read lengths
f = self.open(support.TESTFN, encoding='test_decoder')
- self.assertEquals(f.read(i), decoded[:i])
+ self.assertEqual(f.read(i), decoded[:i])
cookie = f.tell()
- self.assertEquals(f.read(j), decoded[i:i + j])
+ self.assertEqual(f.read(j), decoded[i:i + j])
f.seek(cookie)
- self.assertEquals(f.read(), decoded[i:])
+ self.assertEqual(f.read(), decoded[i:])
f.close()
# Enable the test decoder.
@@ -2037,10 +2037,10 @@
f.write(data)
f.write(data)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
- self.assertEquals(buf.getvalue(), (data * 2).encode(encoding))
+ self.assertEqual(f.read(), data * 2)
+ self.assertEqual(buf.getvalue(), (data * 2).encode(encoding))
def test_unreadable(self):
class UnReadable(self.BytesIO):
@@ -2057,7 +2057,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, "AA\nBB")
+ self.assertEqual(reads, "AA\nBB")
def test_readlines(self):
txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC"))
@@ -2077,7 +2077,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, "A"*127+"\nB")
+ self.assertEqual(reads, "A"*127+"\nB")
def test_issue1395_1(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2089,7 +2089,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_2(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2101,7 +2101,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_3(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2112,7 +2112,7 @@
reads += txt.readline()
reads += txt.readline()
reads += txt.readline()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_4(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2120,7 +2120,7 @@
reads = txt.read(4)
reads += txt.read()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_5(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2130,7 +2130,7 @@
pos = txt.tell()
txt.seek(0)
txt.seek(pos)
- self.assertEquals(txt.read(4), "BBB\n")
+ self.assertEqual(txt.read(4), "BBB\n")
def test_issue2282(self):
buffer = self.BytesIO(self.testdata)
@@ -2146,12 +2146,12 @@
f.write('aaa')
pos = f.tell()
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'aaa'.encode(charset))
+ self.assertEqual(f.read(), 'aaa'.encode(charset))
with self.open(filename, 'a', encoding=charset) as f:
f.write('xxx')
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'aaaxxx'.encode(charset))
+ self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
def test_seek_bom(self):
# Same test, but when seeking manually
@@ -2166,7 +2166,7 @@
f.seek(0)
f.write('bbb')
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'bbbzzz'.encode(charset))
+ self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
def test_errors_property(self):
with self.open(support.TESTFN, "w") as f:
@@ -2194,7 +2194,7 @@
with self.open(support.TESTFN) as f:
content = f.read()
for n in range(20):
- self.assertEquals(content.count("Thread%03d\n" % n), 1)
+ self.assertEqual(content.count("Thread%03d\n" % n), 1)
def test_flush_error_on_close(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2248,9 +2248,9 @@
def _check_decode(b, s, **kwargs):
# We exercise getstate() / setstate() as well as decode()
state = decoder.getstate()
- self.assertEquals(decoder.decode(b, **kwargs), s)
+ self.assertEqual(decoder.decode(b, **kwargs), s)
decoder.setstate(state)
- self.assertEquals(decoder.decode(b, **kwargs), s)
+ self.assertEqual(decoder.decode(b, **kwargs), s)
_check_decode(b'\xe8\xa2\x88', "\u8888")
@@ -2299,24 +2299,24 @@
# Decode one char at a time
for c in s:
result.append(decoder.decode(c))
- self.assertEquals(decoder.newlines, None)
+ self.assertEqual(decoder.newlines, None)
_decode_bytewise("abc\n\r")
- self.assertEquals(decoder.newlines, '\n')
+ self.assertEqual(decoder.newlines, '\n')
_decode_bytewise("\nabc")
- self.assertEquals(decoder.newlines, ('\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\n', '\r\n'))
_decode_bytewise("abc\r")
- self.assertEquals(decoder.newlines, ('\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\n', '\r\n'))
_decode_bytewise("abc")
- self.assertEquals(decoder.newlines, ('\r', '\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n'))
_decode_bytewise("abc\r")
- self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc")
+ self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc")
decoder.reset()
input = "abc"
if encoder is not None:
encoder.reset()
input = encoder.encode(input)
- self.assertEquals(decoder.decode(input), "abc")
- self.assertEquals(decoder.newlines, None)
+ self.assertEqual(decoder.decode(input), "abc")
+ self.assertEqual(decoder.newlines, None)
def test_newline_decoder(self):
encodings = (
@@ -2337,11 +2337,11 @@
def test_newline_bytes(self):
# Issue 5433: Excessive optimization in IncrementalNewlineDecoder
def _check(dec):
- self.assertEquals(dec.newlines, None)
- self.assertEquals(dec.decode("\u0D00"), "\u0D00")
- self.assertEquals(dec.newlines, None)
- self.assertEquals(dec.decode("\u0A00"), "\u0A00")
- self.assertEquals(dec.newlines, None)
+ self.assertEqual(dec.newlines, None)
+ self.assertEqual(dec.decode("\u0D00"), "\u0D00")
+ self.assertEqual(dec.newlines, None)
+ self.assertEqual(dec.decode("\u0A00"), "\u0A00")
+ self.assertEqual(dec.newlines, None)
dec = self.IncrementalNewlineDecoder(None, translate=False)
_check(dec)
dec = self.IncrementalNewlineDecoder(None, translate=True)
@@ -2374,28 +2374,28 @@
def test_attributes(self):
f = self.open(support.TESTFN, "wb", buffering=0)
- self.assertEquals(f.mode, "wb")
+ self.assertEqual(f.mode, "wb")
f.close()
f = self.open(support.TESTFN, "U")
- self.assertEquals(f.name, support.TESTFN)
- self.assertEquals(f.buffer.name, support.TESTFN)
- self.assertEquals(f.buffer.raw.name, support.TESTFN)
- self.assertEquals(f.mode, "U")
- self.assertEquals(f.buffer.mode, "rb")
- self.assertEquals(f.buffer.raw.mode, "rb")
+ self.assertEqual(f.name, support.TESTFN)
+ self.assertEqual(f.buffer.name, support.TESTFN)
+ self.assertEqual(f.buffer.raw.name, support.TESTFN)
+ self.assertEqual(f.mode, "U")
+ self.assertEqual(f.buffer.mode, "rb")
+ self.assertEqual(f.buffer.raw.mode, "rb")
f.close()
f = self.open(support.TESTFN, "w+")
- self.assertEquals(f.mode, "w+")
- self.assertEquals(f.buffer.mode, "rb+") # Does it really matter?
- self.assertEquals(f.buffer.raw.mode, "rb+")
+ self.assertEqual(f.mode, "w+")
+ self.assertEqual(f.buffer.mode, "rb+") # Does it really matter?
+ self.assertEqual(f.buffer.raw.mode, "rb+")
g = self.open(f.fileno(), "wb", closefd=False)
- self.assertEquals(g.mode, "wb")
- self.assertEquals(g.raw.mode, "wb")
- self.assertEquals(g.name, f.fileno())
- self.assertEquals(g.raw.name, f.fileno())
+ self.assertEqual(g.mode, "wb")
+ self.assertEqual(g.raw.mode, "wb")
+ self.assertEqual(g.name, f.fileno())
+ self.assertEqual(g.raw.name, f.fileno())
f.close()
g.close()
diff --git a/Lib/test/test_ioctl.py b/Lib/test/test_ioctl.py
index 38215d9..26c0d05 100644
--- a/Lib/test/test_ioctl.py
+++ b/Lib/test/test_ioctl.py
@@ -50,7 +50,7 @@
with open("/dev/tty", "r") as tty:
r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1)
rpgrp = buf[0]
- self.assertEquals(r, 0)
+ self.assertEqual(r, 0)
self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids))
def test_ioctl_mutate(self):
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 16e65ca..479167e 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -195,7 +195,7 @@
regular_combs = list(combinations(values, r)) # compare to combs without replacement
if n == 0 or r <= 1:
- self.assertEquals(result, regular_combs) # cases that should be identical
+ self.assertEqual(result, regular_combs) # cases that should be identical
else:
self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs
@@ -291,20 +291,20 @@
comb = list(combinations(s, r))
# Check size
- self.assertEquals(len(prod), n**r)
- self.assertEquals(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r))
- self.assertEquals(len(perm), 0 if r>n else fact(n) / fact(n-r))
- self.assertEquals(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r))
+ self.assertEqual(len(prod), n**r)
+ self.assertEqual(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r))
+ self.assertEqual(len(perm), 0 if r>n else fact(n) / fact(n-r))
+ self.assertEqual(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r))
# Check lexicographic order without repeated tuples
- self.assertEquals(prod, sorted(set(prod)))
- self.assertEquals(cwr, sorted(set(cwr)))
- self.assertEquals(perm, sorted(set(perm)))
- self.assertEquals(comb, sorted(set(comb)))
+ self.assertEqual(prod, sorted(set(prod)))
+ self.assertEqual(cwr, sorted(set(cwr)))
+ self.assertEqual(perm, sorted(set(perm)))
+ self.assertEqual(comb, sorted(set(comb)))
# Check interrelationships
- self.assertEquals(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted
- self.assertEquals(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups
+ self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted
+ self.assertEqual(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups
self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted
self.assertEqual(comb, [t for t in cwr if len(set(t))==r]) # comb: cwrs without dups
self.assertEqual(comb, list(filter(set(cwr).__contains__, perm))) # comb: perm that is a cwr
diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py
index b771a6c..e10dfce 100644
--- a/Lib/test/test_keywordonlyarg.py
+++ b/Lib/test/test_keywordonlyarg.py
@@ -93,51 +93,51 @@
pass
def testFunctionCall(self):
- self.assertEquals(1, posonly_sum(1))
- self.assertEquals(1+2, posonly_sum(1,**{"2":2}))
- self.assertEquals(1+2+3, posonly_sum(1,*(2,3)))
- self.assertEquals(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4}))
+ self.assertEqual(1, posonly_sum(1))
+ self.assertEqual(1+2, posonly_sum(1,**{"2":2}))
+ self.assertEqual(1+2+3, posonly_sum(1,*(2,3)))
+ self.assertEqual(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4}))
- self.assertEquals(1, keywordonly_sum(k2=1))
- self.assertEquals(1+2, keywordonly_sum(k1=1, k2=2))
+ self.assertEqual(1, keywordonly_sum(k2=1))
+ self.assertEqual(1+2, keywordonly_sum(k1=1, k2=2))
- self.assertEquals(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2))
- self.assertEquals(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3))
- self.assertEquals(1+2+3+4,
- keywordonly_and_kwarg_sum(k1=1, k2=2,
+ self.assertEqual(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2))
+ self.assertEqual(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3))
+ self.assertEqual(1+2+3+4,
+ keywordonly_and_kwarg_sum(k1=1, k2=2,
**{"a":3,"b":4}))
- self.assertEquals(1+2, mixedargs_sum(1, k1=2))
- self.assertEquals(1+2+3, mixedargs_sum(1, 2, k1=3))
- self.assertEquals(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4))
- self.assertEquals(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5))
+ self.assertEqual(1+2, mixedargs_sum(1, k1=2))
+ self.assertEqual(1+2+3, mixedargs_sum(1, 2, k1=3))
+ self.assertEqual(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4))
+ self.assertEqual(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5))
- self.assertEquals(1+2, mixedargs_sum2(1, k1=2))
- self.assertEquals(1+2+3, mixedargs_sum2(1, 2, k1=3))
- self.assertEquals(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4))
- self.assertEquals(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5))
- self.assertEquals(1+2+3+4+5+6,
- mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6))
- self.assertEquals(1+2+3+4+5+6,
- mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6}))
+ self.assertEqual(1+2, mixedargs_sum2(1, k1=2))
+ self.assertEqual(1+2+3, mixedargs_sum2(1, 2, k1=3))
+ self.assertEqual(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4))
+ self.assertEqual(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5))
+ self.assertEqual(1+2+3+4+5+6,
+ mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6))
+ self.assertEqual(1+2+3+4+5+6,
+ mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6}))
- self.assertEquals(1, Foo(k1=1).sum())
- self.assertEquals(1+2, Foo(k1=1,k2=2).sum())
+ self.assertEqual(1, Foo(k1=1).sum())
+ self.assertEqual(1+2, Foo(k1=1,k2=2).sum())
- self.assertEquals([1,2,3], sortnum(3,2,1))
- self.assertEquals([3,2,1], sortnum(1,2,3, reverse=True))
+ self.assertEqual([1,2,3], sortnum(3,2,1))
+ self.assertEqual([3,2,1], sortnum(1,2,3, reverse=True))
- self.assertEquals(['a','b','c'], sortwords('a','c','b'))
- self.assertEquals(['c','b','a'], sortwords('a','c','b', reverse=True))
- self.assertEquals(['c','b','a'],
- sortwords('a','c','b', reverse=True, ignore='ignore'))
+ self.assertEqual(['a','b','c'], sortwords('a','c','b'))
+ self.assertEqual(['c','b','a'], sortwords('a','c','b', reverse=True))
+ self.assertEqual(['c','b','a'],
+ sortwords('a','c','b', reverse=True, ignore='ignore'))
def testKwDefaults(self):
def foo(p1,p2=0, *, k1, k2=0):
return p1 + p2 + k1 + k2
- self.assertEquals(2, foo.__code__.co_kwonlyargcount)
- self.assertEquals({"k2":0}, foo.__kwdefaults__)
+ self.assertEqual(2, foo.__code__.co_kwonlyargcount)
+ self.assertEqual({"k2":0}, foo.__kwdefaults__)
foo.__kwdefaults__ = {"k1":0}
try:
foo(1,k1=10)
diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py
index 5ba21a2..a90f12c 100644
--- a/Lib/test/test_kqueue.py
+++ b/Lib/test/test_kqueue.py
@@ -80,7 +80,7 @@
try:
client.connect(('127.0.0.1', serverSocket.getsockname()[1]))
except socket.error as e:
- self.assertEquals(e.args[0], errno.EINPROGRESS)
+ self.assertEqual(e.args[0], errno.EINPROGRESS)
else:
#raise AssertionError("Connect should have raised EINPROGRESS")
pass # FreeBSD doesn't raise an exception here
@@ -114,7 +114,7 @@
events = kq.control(None, 4, 1)
events = [(e.ident, e.filter, e.flags) for e in events]
events.sort()
- self.assertEquals(events, [
+ self.assertEqual(events, [
(client.fileno(), select.KQ_FILTER_WRITE, flags),
(server.fileno(), select.KQ_FILTER_WRITE, flags)])
@@ -133,7 +133,7 @@
events = [(e.ident, e.filter, e.flags) for e in events]
events.sort()
- self.assertEquals(events, [
+ self.assertEqual(events, [
(client.fileno(), select.KQ_FILTER_WRITE, flags),
(client.fileno(), select.KQ_FILTER_READ, flags),
(server.fileno(), select.KQ_FILTER_WRITE, flags),
@@ -156,7 +156,7 @@
events = kq.control([], 4, 0.99)
events = [(e.ident, e.filter, e.flags) for e in events]
events.sort()
- self.assertEquals(events, [
+ self.assertEqual(events, [
(server.fileno(), select.KQ_FILTER_WRITE, flags)])
client.close()
@@ -173,7 +173,7 @@
r = kq.control([event1, event2], 1, 1)
self.assertTrue(r)
self.assertFalse(r[0].flags & select.KQ_EV_ERROR)
- self.assertEquals(b.recv(r[0].data), b'foo')
+ self.assertEqual(b.recv(r[0].data), b'foo')
a.close()
b.close()
diff --git a/Lib/test/test_linecache.py b/Lib/test/test_linecache.py
index d4c4777..8e225d5 100644
--- a/Lib/test/test_linecache.py
+++ b/Lib/test/test_linecache.py
@@ -42,31 +42,31 @@
getline = linecache.getline
# Bad values for line number should return an empty string
- self.assertEquals(getline(FILENAME, 2**15), EMPTY)
- self.assertEquals(getline(FILENAME, -1), EMPTY)
+ self.assertEqual(getline(FILENAME, 2**15), EMPTY)
+ self.assertEqual(getline(FILENAME, -1), EMPTY)
# Float values currently raise TypeError, should it?
self.assertRaises(TypeError, getline, FILENAME, 1.1)
# Bad filenames should return an empty string
- self.assertEquals(getline(EMPTY, 1), EMPTY)
- self.assertEquals(getline(INVALID_NAME, 1), EMPTY)
+ self.assertEqual(getline(EMPTY, 1), EMPTY)
+ self.assertEqual(getline(INVALID_NAME, 1), EMPTY)
# Check whether lines correspond to those from file iteration
for entry in TESTS:
filename = os.path.join(TEST_PATH, entry) + '.py'
for index, line in enumerate(open(filename)):
- self.assertEquals(line, getline(filename, index + 1))
+ self.assertEqual(line, getline(filename, index + 1))
# Check module loading
for entry in MODULES:
filename = os.path.join(MODULE_PATH, entry) + '.py'
for index, line in enumerate(open(filename)):
- self.assertEquals(line, getline(filename, index + 1))
+ self.assertEqual(line, getline(filename, index + 1))
# Check that bogus data isn't returned (issue #1309567)
empty = linecache.getlines('a/b/c/__init__.py')
- self.assertEquals(empty, [])
+ self.assertEqual(empty, [])
def test_no_ending_newline(self):
self.addCleanup(support.unlink, support.TESTFN)
@@ -84,12 +84,12 @@
# Are all files cached?
cached_empty = [fn for fn in cached if fn not in linecache.cache]
- self.assertEquals(cached_empty, [])
+ self.assertEqual(cached_empty, [])
# Can we clear the cache?
linecache.clearcache()
cached_empty = [fn for fn in cached if fn in linecache.cache]
- self.assertEquals(cached_empty, [])
+ self.assertEqual(cached_empty, [])
def test_checkcache(self):
getline = linecache.getline
@@ -103,7 +103,7 @@
source_list = []
with open(source_name) as source:
for index, line in enumerate(source):
- self.assertEquals(line, getline(source_name, index + 1))
+ self.assertEqual(line, getline(source_name, index + 1))
source_list.append(line)
with open(source_name, 'w') as source:
@@ -114,13 +114,13 @@
# Check that the cache matches the old contents
for index, line in enumerate(source_list):
- self.assertEquals(line, getline(source_name, index + 1))
+ self.assertEqual(line, getline(source_name, index + 1))
# Update the cache and check whether it matches the new source file
linecache.checkcache(source_name)
with open(source_name) as source:
for index, line in enumerate(source):
- self.assertEquals(line, getline(source_name, index + 1))
+ self.assertEqual(line, getline(source_name, index + 1))
source_list.append(line)
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 0575149..05a7f9e 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -111,13 +111,13 @@
except AttributeError:
# StringIO.StringIO lacks a reset() method.
actual_lines = stream.getvalue().splitlines()
- self.assertEquals(len(actual_lines), len(expected_values))
+ self.assertEqual(len(actual_lines), len(expected_values))
for actual, expected in zip(actual_lines, expected_values):
match = pat.search(actual)
if not match:
self.fail("Log line does not match expected pattern:\n" +
actual)
- self.assertEquals(tuple(match.groups()), expected)
+ self.assertEqual(tuple(match.groups()), expected)
s = stream.read()
if s:
self.fail("Remaining output at end of log stream:\n" + s)
@@ -689,7 +689,7 @@
except RuntimeError:
logging.exception("just testing")
sys.stdout.seek(0)
- self.assertEquals(output.getvalue(),
+ self.assertEqual(output.getvalue(),
"ERROR:root:just testing\nGot a [RuntimeError]\n")
# Original logger output is empty
self.assert_log_lines([])
@@ -807,7 +807,7 @@
logger = logging.getLogger("tcp")
logger.error("spam")
logger.debug("eggs")
- self.assertEquals(self.get_output(), "spam\neggs\n")
+ self.assertEqual(self.get_output(), "spam\neggs\n")
class MemoryTest(BaseTest):
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index a596cf8..9c2bac7 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -510,9 +510,9 @@
try:
int(TruncReturnsNonIntegral())
except TypeError as e:
- self.assertEquals(str(e),
- "__trunc__ returned non-Integral"
- " (type NonIntegral)")
+ self.assertEqual(str(e),
+ "__trunc__ returned non-Integral"
+ " (type NonIntegral)")
else:
self.fail("Failed to raise TypeError with %s" %
((base, trunc_result_base),))
diff --git a/Lib/test/test_macpath.py b/Lib/test/test_macpath.py
index e13865d..b5157bf 100644
--- a/Lib/test/test_macpath.py
+++ b/Lib/test/test_macpath.py
@@ -45,77 +45,77 @@
def test_split(self):
split = macpath.split
- self.assertEquals(split("foo:bar"),
- ('foo:', 'bar'))
- self.assertEquals(split("conky:mountpoint:foo:bar"),
- ('conky:mountpoint:foo', 'bar'))
+ self.assertEqual(split("foo:bar"),
+ ('foo:', 'bar'))
+ self.assertEqual(split("conky:mountpoint:foo:bar"),
+ ('conky:mountpoint:foo', 'bar'))
- self.assertEquals(split(":"), ('', ''))
- self.assertEquals(split(":conky:mountpoint:"),
- (':conky:mountpoint', ''))
+ self.assertEqual(split(":"), ('', ''))
+ self.assertEqual(split(":conky:mountpoint:"),
+ (':conky:mountpoint', ''))
- self.assertEquals(split(b"foo:bar"),
- (b'foo:', b'bar'))
- self.assertEquals(split(b"conky:mountpoint:foo:bar"),
- (b'conky:mountpoint:foo', b'bar'))
+ self.assertEqual(split(b"foo:bar"),
+ (b'foo:', b'bar'))
+ self.assertEqual(split(b"conky:mountpoint:foo:bar"),
+ (b'conky:mountpoint:foo', b'bar'))
- self.assertEquals(split(b":"), (b'', b''))
- self.assertEquals(split(b":conky:mountpoint:"),
- (b':conky:mountpoint', b''))
+ self.assertEqual(split(b":"), (b'', b''))
+ self.assertEqual(split(b":conky:mountpoint:"),
+ (b':conky:mountpoint', b''))
def test_join(self):
join = macpath.join
- self.assertEquals(join('a', 'b'), ':a:b')
- self.assertEquals(join('', 'a:b'), 'a:b')
- self.assertEquals(join('a:b', 'c'), 'a:b:c')
- self.assertEquals(join('a:b', ':c'), 'a:b:c')
- self.assertEquals(join('a', ':b', ':c'), ':a:b:c')
+ self.assertEqual(join('a', 'b'), ':a:b')
+ self.assertEqual(join('', 'a:b'), 'a:b')
+ self.assertEqual(join('a:b', 'c'), 'a:b:c')
+ self.assertEqual(join('a:b', ':c'), 'a:b:c')
+ self.assertEqual(join('a', ':b', ':c'), ':a:b:c')
- self.assertEquals(join(b'a', b'b'), b':a:b')
- self.assertEquals(join(b'', b'a:b'), b'a:b')
- self.assertEquals(join(b'a:b', b'c'), b'a:b:c')
- self.assertEquals(join(b'a:b', b':c'), b'a:b:c')
- self.assertEquals(join(b'a', b':b', b':c'), b':a:b:c')
+ self.assertEqual(join(b'a', b'b'), b':a:b')
+ self.assertEqual(join(b'', b'a:b'), b'a:b')
+ self.assertEqual(join(b'a:b', b'c'), b'a:b:c')
+ self.assertEqual(join(b'a:b', b':c'), b'a:b:c')
+ self.assertEqual(join(b'a', b':b', b':c'), b':a:b:c')
def test_splitdrive(self):
splitdrive = macpath.splitdrive
- self.assertEquals(splitdrive("foo:bar"), ('', 'foo:bar'))
- self.assertEquals(splitdrive(":foo:bar"), ('', ':foo:bar'))
+ self.assertEqual(splitdrive("foo:bar"), ('', 'foo:bar'))
+ self.assertEqual(splitdrive(":foo:bar"), ('', ':foo:bar'))
- self.assertEquals(splitdrive(b"foo:bar"), (b'', b'foo:bar'))
- self.assertEquals(splitdrive(b":foo:bar"), (b'', b':foo:bar'))
+ self.assertEqual(splitdrive(b"foo:bar"), (b'', b'foo:bar'))
+ self.assertEqual(splitdrive(b":foo:bar"), (b'', b':foo:bar'))
def test_splitext(self):
splitext = macpath.splitext
- self.assertEquals(splitext(":foo.ext"), (':foo', '.ext'))
- self.assertEquals(splitext("foo:foo.ext"), ('foo:foo', '.ext'))
- self.assertEquals(splitext(".ext"), ('.ext', ''))
- self.assertEquals(splitext("foo.ext:foo"), ('foo.ext:foo', ''))
- self.assertEquals(splitext(":foo.ext:"), (':foo.ext:', ''))
- self.assertEquals(splitext(""), ('', ''))
- self.assertEquals(splitext("foo.bar.ext"), ('foo.bar', '.ext'))
+ self.assertEqual(splitext(":foo.ext"), (':foo', '.ext'))
+ self.assertEqual(splitext("foo:foo.ext"), ('foo:foo', '.ext'))
+ self.assertEqual(splitext(".ext"), ('.ext', ''))
+ self.assertEqual(splitext("foo.ext:foo"), ('foo.ext:foo', ''))
+ self.assertEqual(splitext(":foo.ext:"), (':foo.ext:', ''))
+ self.assertEqual(splitext(""), ('', ''))
+ self.assertEqual(splitext("foo.bar.ext"), ('foo.bar', '.ext'))
- self.assertEquals(splitext(b":foo.ext"), (b':foo', b'.ext'))
- self.assertEquals(splitext(b"foo:foo.ext"), (b'foo:foo', b'.ext'))
- self.assertEquals(splitext(b".ext"), (b'.ext', b''))
- self.assertEquals(splitext(b"foo.ext:foo"), (b'foo.ext:foo', b''))
- self.assertEquals(splitext(b":foo.ext:"), (b':foo.ext:', b''))
- self.assertEquals(splitext(b""), (b'', b''))
- self.assertEquals(splitext(b"foo.bar.ext"), (b'foo.bar', b'.ext'))
+ self.assertEqual(splitext(b":foo.ext"), (b':foo', b'.ext'))
+ self.assertEqual(splitext(b"foo:foo.ext"), (b'foo:foo', b'.ext'))
+ self.assertEqual(splitext(b".ext"), (b'.ext', b''))
+ self.assertEqual(splitext(b"foo.ext:foo"), (b'foo.ext:foo', b''))
+ self.assertEqual(splitext(b":foo.ext:"), (b':foo.ext:', b''))
+ self.assertEqual(splitext(b""), (b'', b''))
+ self.assertEqual(splitext(b"foo.bar.ext"), (b'foo.bar', b'.ext'))
def test_ismount(self):
ismount = macpath.ismount
- self.assertEquals(ismount("a:"), True)
- self.assertEquals(ismount("a:b"), False)
- self.assertEquals(ismount("a:b:"), True)
- self.assertEquals(ismount(""), False)
- self.assertEquals(ismount(":"), False)
+ self.assertEqual(ismount("a:"), True)
+ self.assertEqual(ismount("a:b"), False)
+ self.assertEqual(ismount("a:b:"), True)
+ self.assertEqual(ismount(""), False)
+ self.assertEqual(ismount(":"), False)
- self.assertEquals(ismount(b"a:"), True)
- self.assertEquals(ismount(b"a:b"), False)
- self.assertEquals(ismount(b"a:b:"), True)
- self.assertEquals(ismount(b""), False)
- self.assertEquals(ismount(b":"), False)
+ self.assertEqual(ismount(b"a:"), True)
+ self.assertEqual(ismount(b"a:b"), False)
+ self.assertEqual(ismount(b"a:b:"), True)
+ self.assertEqual(ismount(b""), False)
+ self.assertEqual(ismount(b":"), False)
def test_normpath(self):
normpath = macpath.normpath
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 6688785..20f53b8 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -155,8 +155,8 @@
def test_version_argument(self):
# Python 2.4.0 crashes for any call to marshal.dumps(x, y)
- self.assertEquals(marshal.loads(marshal.dumps(5, 0)), 5)
- self.assertEquals(marshal.loads(marshal.dumps(5, 1)), 5)
+ self.assertEqual(marshal.loads(marshal.dumps(5, 0)), 5)
+ self.assertEqual(marshal.loads(marshal.dumps(5, 1)), 5)
def test_fuzz(self):
# simple test that it's at least not *totally* trivial to
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index 7505948..e53bf2e 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -80,7 +80,7 @@
self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
self.assertRaises(ValueError, math.acosh, 0)
self.assertRaises(ValueError, math.acosh, -1)
- self.assertEquals(math.acosh(INF), INF)
+ self.assertEqual(math.acosh(INF), INF)
self.assertRaises(ValueError, math.acosh, NINF)
self.assertTrue(math.isnan(math.acosh(NAN)))
@@ -98,8 +98,8 @@
self.ftest('asinh(0)', math.asinh(0), 0)
self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)
self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)
- self.assertEquals(math.asinh(INF), INF)
- self.assertEquals(math.asinh(NINF), NINF)
+ self.assertEqual(math.asinh(INF), INF)
+ self.assertEqual(math.asinh(NINF), NINF)
self.assertTrue(math.isnan(math.asinh(NAN)))
def testAtan(self):
@@ -185,15 +185,15 @@
def testCeil(self):
self.assertRaises(TypeError, math.ceil)
- self.assertEquals(int, type(math.ceil(0.5)))
+ self.assertEqual(int, type(math.ceil(0.5)))
self.ftest('ceil(0.5)', math.ceil(0.5), 1)
self.ftest('ceil(1.0)', math.ceil(1.0), 1)
self.ftest('ceil(1.5)', math.ceil(1.5), 2)
self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)
self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
- #self.assertEquals(math.ceil(INF), INF)
- #self.assertEquals(math.ceil(NINF), NINF)
+ #self.assertEqual(math.ceil(INF), INF)
+ #self.assertEqual(math.ceil(NINF), NINF)
#self.assertTrue(math.isnan(math.ceil(NAN)))
class TestCeil:
@@ -219,19 +219,19 @@
self.assertRaises(TypeError, math.copysign)
# copysign should let us distinguish signs of zeros
- self.assertEquals(math.copysign(1., 0.), 1.)
- self.assertEquals(math.copysign(1., -0.), -1.)
- self.assertEquals(math.copysign(INF, 0.), INF)
- self.assertEquals(math.copysign(INF, -0.), NINF)
- self.assertEquals(math.copysign(NINF, 0.), INF)
- self.assertEquals(math.copysign(NINF, -0.), NINF)
+ self.assertEqual(math.copysign(1., 0.), 1.)
+ self.assertEqual(math.copysign(1., -0.), -1.)
+ self.assertEqual(math.copysign(INF, 0.), INF)
+ self.assertEqual(math.copysign(INF, -0.), NINF)
+ self.assertEqual(math.copysign(NINF, 0.), INF)
+ self.assertEqual(math.copysign(NINF, -0.), NINF)
# and of infinities
- self.assertEquals(math.copysign(1., INF), 1.)
- self.assertEquals(math.copysign(1., NINF), -1.)
- self.assertEquals(math.copysign(INF, INF), INF)
- self.assertEquals(math.copysign(INF, NINF), NINF)
- self.assertEquals(math.copysign(NINF, INF), INF)
- self.assertEquals(math.copysign(NINF, NINF), NINF)
+ self.assertEqual(math.copysign(1., INF), 1.)
+ self.assertEqual(math.copysign(1., NINF), -1.)
+ self.assertEqual(math.copysign(INF, INF), INF)
+ self.assertEqual(math.copysign(INF, NINF), NINF)
+ self.assertEqual(math.copysign(NINF, INF), INF)
+ self.assertEqual(math.copysign(NINF, NINF), NINF)
self.assertTrue(math.isnan(math.copysign(NAN, 1.)))
self.assertTrue(math.isnan(math.copysign(NAN, INF)))
self.assertTrue(math.isnan(math.copysign(NAN, NINF)))
@@ -241,7 +241,7 @@
# given platform.
self.assertTrue(math.isinf(math.copysign(INF, NAN)))
# similarly, copysign(2., NAN) could be 2. or -2.
- self.assertEquals(abs(math.copysign(2., NAN)), 2.)
+ self.assertEqual(abs(math.copysign(2., NAN)), 2.)
def testCos(self):
self.assertRaises(TypeError, math.cos)
@@ -261,8 +261,8 @@
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
- self.assertEquals(math.cosh(INF), INF)
- self.assertEquals(math.cosh(NINF), INF)
+ self.assertEqual(math.cosh(INF), INF)
+ self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN)))
def testDegrees(self):
@@ -276,8 +276,8 @@
self.ftest('exp(-1)', math.exp(-1), 1/math.e)
self.ftest('exp(0)', math.exp(0), 1)
self.ftest('exp(1)', math.exp(1), math.e)
- self.assertEquals(math.exp(INF), INF)
- self.assertEquals(math.exp(NINF), 0.)
+ self.assertEqual(math.exp(INF), INF)
+ self.assertEqual(math.exp(NINF), 0.)
self.assertTrue(math.isnan(math.exp(NAN)))
def testFabs(self):
@@ -302,7 +302,7 @@
def testFloor(self):
self.assertRaises(TypeError, math.floor)
- self.assertEquals(int, type(math.floor(0.5)))
+ self.assertEqual(int, type(math.floor(0.5)))
self.ftest('floor(0.5)', math.floor(0.5), 0)
self.ftest('floor(1.0)', math.floor(1.0), 1)
self.ftest('floor(1.5)', math.floor(1.5), 1)
@@ -313,8 +313,8 @@
# This fails on some platforms - so check it here
self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
- #self.assertEquals(math.ceil(INF), INF)
- #self.assertEquals(math.ceil(NINF), NINF)
+ #self.assertEqual(math.ceil(INF), INF)
+ #self.assertEqual(math.ceil(NINF), NINF)
#self.assertTrue(math.isnan(math.floor(NAN)))
class TestFloor:
@@ -345,12 +345,12 @@
self.assertRaises(ValueError, math.fmod, INF, 1.)
self.assertRaises(ValueError, math.fmod, NINF, 1.)
self.assertRaises(ValueError, math.fmod, INF, 0.)
- self.assertEquals(math.fmod(3.0, INF), 3.0)
- self.assertEquals(math.fmod(-3.0, INF), -3.0)
- self.assertEquals(math.fmod(3.0, NINF), 3.0)
- self.assertEquals(math.fmod(-3.0, NINF), -3.0)
- self.assertEquals(math.fmod(0.0, 3.0), 0.0)
- self.assertEquals(math.fmod(0.0, NINF), 0.0)
+ self.assertEqual(math.fmod(3.0, INF), 3.0)
+ self.assertEqual(math.fmod(-3.0, INF), -3.0)
+ self.assertEqual(math.fmod(3.0, NINF), 3.0)
+ self.assertEqual(math.fmod(-3.0, NINF), -3.0)
+ self.assertEqual(math.fmod(0.0, 3.0), 0.0)
+ self.assertEqual(math.fmod(0.0, NINF), 0.0)
def testFrexp(self):
self.assertRaises(TypeError, math.frexp)
@@ -366,8 +366,8 @@
testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
testfrexp('frexp(2)', math.frexp(2), (0.5, 2))
- self.assertEquals(math.frexp(INF)[0], INF)
- self.assertEquals(math.frexp(NINF)[0], NINF)
+ self.assertEqual(math.frexp(INF)[0], INF)
+ self.assertEqual(math.frexp(NINF)[0], NINF)
self.assertTrue(math.isnan(math.frexp(NAN)[0]))
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
@@ -481,28 +481,28 @@
self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
- self.assertEquals(math.ldexp(1., -1000000), 0.)
- self.assertEquals(math.ldexp(-1., -1000000), -0.)
- self.assertEquals(math.ldexp(INF, 30), INF)
- self.assertEquals(math.ldexp(NINF, -213), NINF)
+ self.assertEqual(math.ldexp(1., -1000000), 0.)
+ self.assertEqual(math.ldexp(-1., -1000000), -0.)
+ self.assertEqual(math.ldexp(INF, 30), INF)
+ self.assertEqual(math.ldexp(NINF, -213), NINF)
self.assertTrue(math.isnan(math.ldexp(NAN, 0)))
# large second argument
for n in [10**5, 10**10, 10**20, 10**40]:
- self.assertEquals(math.ldexp(INF, -n), INF)
- self.assertEquals(math.ldexp(NINF, -n), NINF)
- self.assertEquals(math.ldexp(1., -n), 0.)
- self.assertEquals(math.ldexp(-1., -n), -0.)
- self.assertEquals(math.ldexp(0., -n), 0.)
- self.assertEquals(math.ldexp(-0., -n), -0.)
+ self.assertEqual(math.ldexp(INF, -n), INF)
+ self.assertEqual(math.ldexp(NINF, -n), NINF)
+ self.assertEqual(math.ldexp(1., -n), 0.)
+ self.assertEqual(math.ldexp(-1., -n), -0.)
+ self.assertEqual(math.ldexp(0., -n), 0.)
+ self.assertEqual(math.ldexp(-0., -n), -0.)
self.assertTrue(math.isnan(math.ldexp(NAN, -n)))
self.assertRaises(OverflowError, math.ldexp, 1., n)
self.assertRaises(OverflowError, math.ldexp, -1., n)
- self.assertEquals(math.ldexp(0., n), 0.)
- self.assertEquals(math.ldexp(-0., n), -0.)
- self.assertEquals(math.ldexp(INF, n), INF)
- self.assertEquals(math.ldexp(NINF, n), NINF)
+ self.assertEqual(math.ldexp(0., n), 0.)
+ self.assertEqual(math.ldexp(-0., n), -0.)
+ self.assertEqual(math.ldexp(INF, n), INF)
+ self.assertEqual(math.ldexp(NINF, n), NINF)
self.assertTrue(math.isnan(math.ldexp(NAN, n)))
def testLog(self):
@@ -513,7 +513,7 @@
self.ftest('log(32,2)', math.log(32,2), 5)
self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
- self.assertEquals(math.log(INF), INF)
+ self.assertEqual(math.log(INF), INF)
self.assertRaises(ValueError, math.log, NINF)
self.assertTrue(math.isnan(math.log(NAN)))
@@ -523,19 +523,19 @@
self.ftest('log1p(0)', math.log1p(0), 0)
self.ftest('log1p(e-1)', math.log1p(math.e-1), 1)
self.ftest('log1p(1)', math.log1p(1), math.log(2))
- self.assertEquals(math.log1p(INF), INF)
+ self.assertEqual(math.log1p(INF), INF)
self.assertRaises(ValueError, math.log1p, NINF)
self.assertTrue(math.isnan(math.log1p(NAN)))
n= 2**90
- self.assertAlmostEquals(math.log1p(n), 62.383246250395075)
- self.assertAlmostEquals(math.log1p(n), math.log1p(float(n)))
+ self.assertAlmostEqual(math.log1p(n), 62.383246250395075)
+ self.assertAlmostEqual(math.log1p(n), math.log1p(float(n)))
def testLog10(self):
self.assertRaises(TypeError, math.log10)
self.ftest('log10(0.1)', math.log10(0.1), -1)
self.ftest('log10(1)', math.log10(1), 0)
self.ftest('log10(10)', math.log10(10), 1)
- self.assertEquals(math.log(INF), INF)
+ self.assertEqual(math.log(INF), INF)
self.assertRaises(ValueError, math.log10, NINF)
self.assertTrue(math.isnan(math.log10(NAN)))
@@ -551,8 +551,8 @@
testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
- self.assertEquals(math.modf(INF), (0.0, INF))
- self.assertEquals(math.modf(NINF), (-0.0, NINF))
+ self.assertEqual(math.modf(INF), (0.0, INF))
+ self.assertEqual(math.modf(NINF), (-0.0, NINF))
modf_nan = math.modf(NAN)
self.assertTrue(math.isnan(modf_nan[0]))
@@ -731,8 +731,8 @@
self.ftest('sinh(0)', math.sinh(0), 0)
self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
- self.assertEquals(math.sinh(INF), INF)
- self.assertEquals(math.sinh(NINF), NINF)
+ self.assertEqual(math.sinh(INF), INF)
+ self.assertEqual(math.sinh(NINF), NINF)
self.assertTrue(math.isnan(math.sinh(NAN)))
def testSqrt(self):
@@ -740,7 +740,7 @@
self.ftest('sqrt(0)', math.sqrt(0), 0)
self.ftest('sqrt(1)', math.sqrt(1), 1)
self.ftest('sqrt(4)', math.sqrt(4), 2)
- self.assertEquals(math.sqrt(INF), INF)
+ self.assertEqual(math.sqrt(INF), INF)
self.assertRaises(ValueError, math.sqrt, NINF)
self.assertTrue(math.isnan(math.sqrt(NAN)))
@@ -799,7 +799,7 @@
# the type only.
#t = TestNoTrunc()
#t.__trunc__ = lambda *args: args
- #self.assertEquals((), math.trunc(t))
+ #self.assertEqual((), math.trunc(t))
#self.assertRaises(TypeError, math.trunc, t, 0)
def testIsnan(self):
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index 027ac94..b45845d 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -20,17 +20,17 @@
buf = self.buftype("1234567890")
bytesIo = self.ioclass(buf)
- self.assertEquals(buf[:1], bytesIo.read(1))
- self.assertEquals(buf[1:5], bytesIo.read(4))
- self.assertEquals(buf[5:], bytesIo.read(900))
- self.assertEquals(self.EOF, bytesIo.read())
+ self.assertEqual(buf[:1], bytesIo.read(1))
+ self.assertEqual(buf[1:5], bytesIo.read(4))
+ self.assertEqual(buf[5:], bytesIo.read(900))
+ self.assertEqual(self.EOF, bytesIo.read())
def testReadNoArgs(self):
buf = self.buftype("1234567890")
bytesIo = self.ioclass(buf)
- self.assertEquals(buf, bytesIo.read())
- self.assertEquals(self.EOF, bytesIo.read())
+ self.assertEqual(buf, bytesIo.read())
+ self.assertEqual(self.EOF, bytesIo.read())
def testSeek(self):
buf = self.buftype("1234567890")
@@ -38,21 +38,21 @@
bytesIo.read(5)
bytesIo.seek(0)
- self.assertEquals(buf, bytesIo.read())
+ self.assertEqual(buf, bytesIo.read())
bytesIo.seek(3)
- self.assertEquals(buf[3:], bytesIo.read())
+ self.assertEqual(buf[3:], bytesIo.read())
self.assertRaises(TypeError, bytesIo.seek, 0.0)
def testTell(self):
buf = self.buftype("1234567890")
bytesIo = self.ioclass(buf)
- self.assertEquals(0, bytesIo.tell())
+ self.assertEqual(0, bytesIo.tell())
bytesIo.seek(5)
- self.assertEquals(5, bytesIo.tell())
+ self.assertEqual(5, bytesIo.tell())
bytesIo.seek(10000)
- self.assertEquals(10000, bytesIo.tell())
+ self.assertEqual(10000, bytesIo.tell())
class MemoryTestMixin:
diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py
index 3f82307..fd820b6 100644
--- a/Lib/test/test_memoryview.py
+++ b/Lib/test/test_memoryview.py
@@ -27,11 +27,11 @@
b = tp(self._source)
oldrefcount = sys.getrefcount(b)
m = self._view(b)
- self.assertEquals(m[0], item(b"a"))
+ self.assertEqual(m[0], item(b"a"))
self.assertTrue(isinstance(m[0], bytes), type(m[0]))
- self.assertEquals(m[5], item(b"f"))
- self.assertEquals(m[-1], item(b"f"))
- self.assertEquals(m[-6], item(b"a"))
+ self.assertEqual(m[5], item(b"f"))
+ self.assertEqual(m[-1], item(b"f"))
+ self.assertEqual(m[-6], item(b"a"))
# Bounds checking
self.assertRaises(IndexError, lambda: m[6])
self.assertRaises(IndexError, lambda: m[-7])
@@ -42,7 +42,7 @@
self.assertRaises(TypeError, lambda: m[0.0])
self.assertRaises(TypeError, lambda: m["a"])
m = None
- self.assertEquals(sys.getrefcount(b), oldrefcount)
+ self.assertEqual(sys.getrefcount(b), oldrefcount)
def test_getitem(self):
for tp in self._types:
@@ -66,7 +66,7 @@
self.assertRaises(TypeError, setitem, 65)
self.assertRaises(TypeError, setitem, memoryview(b"a"))
m = None
- self.assertEquals(sys.getrefcount(b), oldrefcount)
+ self.assertEqual(sys.getrefcount(b), oldrefcount)
def test_setitem_writable(self):
if not self.rw_type:
@@ -109,7 +109,7 @@
self.assertRaises(ValueError, setitem, slice(0,2), b"a")
m = None
- self.assertEquals(sys.getrefcount(b), oldrefcount)
+ self.assertEqual(sys.getrefcount(b), oldrefcount)
def test_delitem(self):
for tp in self._types:
@@ -127,14 +127,14 @@
# This calls self.getitem_type() on each separate byte of b"abcdef"
expected = b"".join(
self.getitem_type(bytes([c])) for c in b"abcdef")
- self.assertEquals(b, expected)
+ self.assertEqual(b, expected)
self.assertTrue(isinstance(b, bytes), type(b))
def test_tolist(self):
for tp in self._types:
m = self._view(tp(self._source))
l = m.tolist()
- self.assertEquals(l, list(b"abcdef"))
+ self.assertEqual(l, list(b"abcdef"))
def test_compare(self):
# memoryviews can compare for equality with other objects
@@ -168,26 +168,26 @@
def check_attributes_with_type(self, tp):
m = self._view(tp(self._source))
- self.assertEquals(m.format, self.format)
- self.assertEquals(m.itemsize, self.itemsize)
- self.assertEquals(m.ndim, 1)
- self.assertEquals(m.shape, (6,))
- self.assertEquals(len(m), 6)
- self.assertEquals(m.strides, (self.itemsize,))
- self.assertEquals(m.suboffsets, None)
+ self.assertEqual(m.format, self.format)
+ self.assertEqual(m.itemsize, self.itemsize)
+ self.assertEqual(m.ndim, 1)
+ self.assertEqual(m.shape, (6,))
+ self.assertEqual(len(m), 6)
+ self.assertEqual(m.strides, (self.itemsize,))
+ self.assertEqual(m.suboffsets, None)
return m
def test_attributes_readonly(self):
if not self.ro_type:
return
m = self.check_attributes_with_type(self.ro_type)
- self.assertEquals(m.readonly, True)
+ self.assertEqual(m.readonly, True)
def test_attributes_writable(self):
if not self.rw_type:
return
m = self.check_attributes_with_type(self.rw_type)
- self.assertEquals(m.readonly, False)
+ self.assertEqual(m.readonly, False)
def test_getbuffer(self):
# Test PyObject_GetBuffer() on a memoryview object.
@@ -198,9 +198,9 @@
oldviewrefcount = sys.getrefcount(m)
s = str(m, "utf-8")
self._check_contents(tp, b, s.encode("utf-8"))
- self.assertEquals(sys.getrefcount(m), oldviewrefcount)
+ self.assertEqual(sys.getrefcount(m), oldviewrefcount)
m = None
- self.assertEquals(sys.getrefcount(b), oldrefcount)
+ self.assertEqual(sys.getrefcount(b), oldrefcount)
def test_gc(self):
for tp in self._types:
@@ -262,7 +262,7 @@
return memoryview(obj)
def _check_contents(self, tp, obj, contents):
- self.assertEquals(obj, tp(contents))
+ self.assertEqual(obj, tp(contents))
class BaseMemorySliceTests:
source_bytes = b"XabcdefY"
@@ -272,14 +272,14 @@
return m[1:7]
def _check_contents(self, tp, obj, contents):
- self.assertEquals(obj[1:7], tp(contents))
+ self.assertEqual(obj[1:7], tp(contents))
def test_refs(self):
for tp in self._types:
m = memoryview(tp(self._source))
oldrefcount = sys.getrefcount(m)
m[1:2]
- self.assertEquals(sys.getrefcount(m), oldrefcount)
+ self.assertEqual(sys.getrefcount(m), oldrefcount)
class BaseMemorySliceSliceTests:
source_bytes = b"XabcdefY"
@@ -289,7 +289,7 @@
return m[:7][1:]
def _check_contents(self, tp, obj, contents):
- self.assertEquals(obj[1:7], tp(contents))
+ self.assertEqual(obj[1:7], tp(contents))
# Concrete test classes
@@ -316,7 +316,7 @@
m = memoryview(a)
new_a = array.array('i', range(9, -1, -1))
m[:] = new_a
- self.assertEquals(a, new_a)
+ self.assertEqual(a, new_a)
class BytesMemorySliceTest(unittest.TestCase,
diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py
index 0a0a663..461ac65 100644
--- a/Lib/test/test_minidom.py
+++ b/Lib/test/test_minidom.py
@@ -753,7 +753,7 @@
def check_clone_pi(self, deep, testName):
doc = parseString("<?target data?><doc/>")
pi = doc.firstChild
- self.assertEquals(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE)
+ self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE)
clone = pi.cloneNode(deep)
self.confirm(clone.target == pi.target
and clone.data == pi.data)
@@ -1223,7 +1223,7 @@
doc = parseString("<doc>a</doc>")
elem = doc.documentElement
text = elem.childNodes[0]
- self.assertEquals(text.nodeType, Node.TEXT_NODE)
+ self.assertEqual(text.nodeType, Node.TEXT_NODE)
self.checkWholeText(text, "a")
elem.appendChild(doc.createTextNode("b"))
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index b6d2ffb..fba688e 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -417,7 +417,7 @@
data = bytes(reversed(data))
L[start:stop:step] = data
m[start:stop:step] = data
- self.assertEquals(m[:], bytes(L))
+ self.assertEqual(m[:], bytes(L))
def make_mmap_file (self, f, halfsize):
# Write 2 pages worth of data to the file
@@ -512,27 +512,27 @@
f.close()
# Test write_byte()
for i in range(len(data)):
- self.assertEquals(m.tell(), i)
+ self.assertEqual(m.tell(), i)
m.write_byte(data[i])
- self.assertEquals(m.tell(), i+1)
+ self.assertEqual(m.tell(), i+1)
self.assertRaises(ValueError, m.write_byte, b"x"[0])
- self.assertEquals(m[:], data)
+ self.assertEqual(m[:], data)
# Test read_byte()
m.seek(0)
for i in range(len(data)):
- self.assertEquals(m.tell(), i)
- self.assertEquals(m.read_byte(), data[i])
- self.assertEquals(m.tell(), i+1)
+ self.assertEqual(m.tell(), i)
+ self.assertEqual(m.read_byte(), data[i])
+ self.assertEqual(m.tell(), i+1)
self.assertRaises(ValueError, m.read_byte)
# Test read()
m.seek(3)
- self.assertEquals(m.read(3), b"345")
- self.assertEquals(m.tell(), 6)
+ self.assertEqual(m.read(3), b"345")
+ self.assertEqual(m.tell(), 6)
# Test write()
m.seek(3)
m.write(b"bar")
- self.assertEquals(m.tell(), 6)
- self.assertEquals(m[:], b"012bar6789")
+ self.assertEqual(m.tell(), 6)
+ self.assertEqual(m[:], b"012bar6789")
m.seek(8)
self.assertRaises(ValueError, m.write, b"bar")
@@ -540,9 +540,9 @@
for b in (129, 200, 255): # > 128
m = mmap.mmap(-1, 1)
m.write_byte(b)
- self.assertEquals(m[0], b)
+ self.assertEqual(m[0], b)
m.seek(0)
- self.assertEquals(m.read_byte(), b)
+ self.assertEqual(m.read_byte(), b)
m.close()
if os.name == 'nt':
@@ -556,8 +556,8 @@
m1[:] = data1
m2 = mmap.mmap(-1, len(data2), tagname="foo")
m2[:] = data2
- self.assertEquals(m1[:], data2)
- self.assertEquals(m2[:], data2)
+ self.assertEqual(m1[:], data2)
+ self.assertEqual(m2[:], data2)
m2.close()
m1.close()
@@ -566,8 +566,8 @@
m1[:] = data1
m2 = mmap.mmap(-1, len(data2), tagname="boo")
m2[:] = data2
- self.assertEquals(m1[:], data1)
- self.assertEquals(m2[:], data2)
+ self.assertEqual(m1[:], data1)
+ self.assertEqual(m2[:], data2)
m2.close()
m1.close()
diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py
index a001e93..52f76ac 100644
--- a/Lib/test/test_multiprocessing.py
+++ b/Lib/test/test_multiprocessing.py
@@ -183,30 +183,30 @@
current = self.current_process()
if self.TYPE != 'threads':
- self.assertEquals(p.authkey, current.authkey)
- self.assertEquals(p.is_alive(), False)
- self.assertEquals(p.daemon, True)
+ self.assertEqual(p.authkey, current.authkey)
+ self.assertEqual(p.is_alive(), False)
+ self.assertEqual(p.daemon, True)
self.assertTrue(p not in self.active_children())
self.assertTrue(type(self.active_children()) is list)
self.assertEqual(p.exitcode, None)
p.start()
- self.assertEquals(p.exitcode, None)
- self.assertEquals(p.is_alive(), True)
+ self.assertEqual(p.exitcode, None)
+ self.assertEqual(p.is_alive(), True)
self.assertTrue(p in self.active_children())
- self.assertEquals(q.get(), args[1:])
- self.assertEquals(q.get(), kwargs)
- self.assertEquals(q.get(), p.name)
+ self.assertEqual(q.get(), args[1:])
+ self.assertEqual(q.get(), kwargs)
+ self.assertEqual(q.get(), p.name)
if self.TYPE != 'threads':
- self.assertEquals(q.get(), current.authkey)
- self.assertEquals(q.get(), p.pid)
+ self.assertEqual(q.get(), current.authkey)
+ self.assertEqual(q.get(), p.pid)
p.join()
- self.assertEquals(p.exitcode, 0)
- self.assertEquals(p.is_alive(), False)
+ self.assertEqual(p.exitcode, 0)
+ self.assertEqual(p.is_alive(), False)
self.assertTrue(p not in self.active_children())
@classmethod
diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py
index 8b7fd9e..9707e84 100644
--- a/Lib/test/test_opcodes.py
+++ b/Lib/test/test_opcodes.py
@@ -68,35 +68,35 @@
f = eval('lambda: None')
g = eval('lambda: None')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda a: a')
g = eval('lambda a: a')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda a=1: a')
g = eval('lambda a=1: a')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda: 0')
g = eval('lambda: 1')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda: None')
g = eval('lambda a: None')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda a: None')
g = eval('lambda b: None')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda a: None')
g = eval('lambda a=None: None')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
f = eval('lambda a=0: None')
g = eval('lambda a=1: None')
- self.assertNotEquals(f, g)
+ self.assertNotEqual(f, g)
def test_modulo_of_string_subclasses(self):
class MyString(str):
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index aa3219f..531f56e 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -357,12 +357,12 @@
f = operator.methodcaller('foo')
self.assertRaises(IndexError, f, a)
f = operator.methodcaller('foo', 1, 2)
- self.assertEquals(f(a), 3)
+ self.assertEqual(f(a), 3)
f = operator.methodcaller('bar')
- self.assertEquals(f(a), 42)
+ self.assertEqual(f(a), 42)
self.assertRaises(TypeError, f, a, a)
f = operator.methodcaller('bar', f=5)
- self.assertEquals(f(a), 5)
+ self.assertEqual(f(a), 5)
def test_inplace(self):
class C(object):
diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py
index b68e31d..4ad4c0f 100644
--- a/Lib/test/test_optparse.py
+++ b/Lib/test/test_optparse.py
@@ -425,13 +425,13 @@
def test_str_aliases_string(self):
self.parser.add_option("-s", type="str")
- self.assertEquals(self.parser.get_option("-s").type, "string")
+ self.assertEqual(self.parser.get_option("-s").type, "string")
def test_type_object(self):
self.parser.add_option("-s", type=str)
- self.assertEquals(self.parser.get_option("-s").type, "string")
+ self.assertEqual(self.parser.get_option("-s").type, "string")
self.parser.add_option("-x", type=int)
- self.assertEquals(self.parser.get_option("-x").type, "int")
+ self.assertEqual(self.parser.get_option("-x").type, "int")
# Custom type for testing processing of default values.
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 9be1aad..d30c45d 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -223,8 +223,8 @@
result = os.stat(self.fname)
# Make sure direct access works
- self.assertEquals(result[stat.ST_SIZE], 3)
- self.assertEquals(result.st_size, 3)
+ self.assertEqual(result[stat.ST_SIZE], 3)
+ self.assertEqual(result.st_size, 3)
import sys
@@ -237,8 +237,8 @@
def trunc(x): return int(x)
else:
def trunc(x): return x
- self.assertEquals(trunc(getattr(result, attr)),
- result[getattr(stat, name)])
+ self.assertEqual(trunc(getattr(result, attr)),
+ result[getattr(stat, name)])
self.assertTrue(attr in members)
try:
@@ -292,13 +292,13 @@
return
# Make sure direct access works
- self.assertEquals(result.f_bfree, result[3])
+ self.assertEqual(result.f_bfree, result[3])
# Make sure all the attributes are there.
members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',
'ffree', 'favail', 'flag', 'namemax')
for value, member in enumerate(members):
- self.assertEquals(getattr(result, 'f_' + member), result[value])
+ self.assertEqual(getattr(result, 'f_' + member), result[value])
# Make sure that assignment really fails
try:
@@ -333,7 +333,7 @@
# time stamps in stat, but not in utime.
os.utime(support.TESTFN, (st.st_atime, int(st.st_mtime-delta)))
st2 = os.stat(support.TESTFN)
- self.assertEquals(st2.st_mtime, int(st.st_mtime-delta))
+ self.assertEqual(st2.st_mtime, int(st.st_mtime-delta))
# Restrict test to Win32, since there is no guarantee other
# systems support centiseconds
@@ -350,7 +350,7 @@
def test_1565150(self):
t1 = 1159195039.25
os.utime(self.fname, (t1, t1))
- self.assertEquals(os.stat(self.fname).st_mtime, t1)
+ self.assertEqual(os.stat(self.fname).st_mtime, t1)
def test_1686475(self):
# Verify that an open file can be stat'ed
@@ -390,24 +390,24 @@
os.environ.update(HELLO="World")
with os.popen("/bin/sh -c 'echo $HELLO'") as popen:
value = popen.read().strip()
- self.assertEquals(value, "World")
+ self.assertEqual(value, "World")
def test_os_popen_iter(self):
if os.path.exists("/bin/sh"):
with os.popen(
"/bin/sh -c 'echo \"line1\nline2\nline3\"'") as popen:
it = iter(popen)
- self.assertEquals(next(it), "line1\n")
- self.assertEquals(next(it), "line2\n")
- self.assertEquals(next(it), "line3\n")
+ self.assertEqual(next(it), "line1\n")
+ self.assertEqual(next(it), "line2\n")
+ self.assertEqual(next(it), "line3\n")
self.assertRaises(StopIteration, next, it)
# Verify environ keys and values from the OS are of the
# correct str type.
def test_keyvalue_types(self):
for key, val in os.environ.items():
- self.assertEquals(type(key), str)
- self.assertEquals(type(val), str)
+ self.assertEqual(type(key), str)
+ self.assertEqual(type(val), str)
def test_items(self):
for key, value in self._reference().items():
@@ -780,7 +780,7 @@
def test_listdir(self):
expected = set(self.unicodefn)
found = set(os.listdir(support.TESTFN))
- self.assertEquals(found, expected)
+ self.assertEqual(found, expected)
def test_open(self):
for fn in self.unicodefn:
diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py
index 04b45be..9ab4171 100644
--- a/Lib/test/test_parser.py
+++ b/Lib/test/test_parser.py
@@ -21,8 +21,8 @@
except parser.ParserError as why:
self.fail("could not roundtrip %r: %s" % (s, why))
- self.assertEquals(t, st2.totuple(),
- "could not re-generate syntax tree")
+ self.assertEqual(t, st2.totuple(),
+ "could not re-generate syntax tree")
def check_expr(self, s):
self.roundtrip(parser.expr, s)
@@ -493,14 +493,14 @@
def test_compile_expr(self):
st = parser.expr('2 + 3')
code = parser.compilest(st)
- self.assertEquals(eval(code), 5)
+ self.assertEqual(eval(code), 5)
def test_compile_suite(self):
st = parser.suite('x = 2; y = x + 3')
code = parser.compilest(st)
globs = {}
exec(code, globs)
- self.assertEquals(globs['y'], 5)
+ self.assertEqual(globs['y'], 5)
def test_compile_error(self):
st = parser.suite('1 = 3 + 4')
@@ -544,36 +544,36 @@
st3_copy = parser.expr('list(x**3 for x in range(20))')
# exercise fast path for object identity
- self.assertEquals(st1 == st1, True)
- self.assertEquals(st2 == st2, True)
- self.assertEquals(st3 == st3, True)
+ self.assertEqual(st1 == st1, True)
+ self.assertEqual(st2 == st2, True)
+ self.assertEqual(st3 == st3, True)
# slow path equality
self.assertEqual(st1, st1_copy)
self.assertEqual(st2, st2_copy)
self.assertEqual(st3, st3_copy)
- self.assertEquals(st1 == st2, False)
- self.assertEquals(st1 == st3, False)
- self.assertEquals(st2 == st3, False)
- self.assertEquals(st1 != st1, False)
- self.assertEquals(st2 != st2, False)
- self.assertEquals(st3 != st3, False)
- self.assertEquals(st1 != st1_copy, False)
- self.assertEquals(st2 != st2_copy, False)
- self.assertEquals(st3 != st3_copy, False)
- self.assertEquals(st2 != st1, True)
- self.assertEquals(st1 != st3, True)
- self.assertEquals(st3 != st2, True)
+ self.assertEqual(st1 == st2, False)
+ self.assertEqual(st1 == st3, False)
+ self.assertEqual(st2 == st3, False)
+ self.assertEqual(st1 != st1, False)
+ self.assertEqual(st2 != st2, False)
+ self.assertEqual(st3 != st3, False)
+ self.assertEqual(st1 != st1_copy, False)
+ self.assertEqual(st2 != st2_copy, False)
+ self.assertEqual(st3 != st3_copy, False)
+ self.assertEqual(st2 != st1, True)
+ self.assertEqual(st1 != st3, True)
+ self.assertEqual(st3 != st2, True)
# we don't particularly care what the ordering is; just that
# it's usable and self-consistent
- self.assertEquals(st1 < st2, not (st2 <= st1))
- self.assertEquals(st1 < st3, not (st3 <= st1))
- self.assertEquals(st2 < st3, not (st3 <= st2))
- self.assertEquals(st1 < st2, st2 > st1)
- self.assertEquals(st1 < st3, st3 > st1)
- self.assertEquals(st2 < st3, st3 > st2)
- self.assertEquals(st1 <= st2, st2 >= st1)
- self.assertEquals(st3 <= st1, st1 >= st3)
- self.assertEquals(st2 <= st3, st3 >= st2)
+ self.assertEqual(st1 < st2, not (st2 <= st1))
+ self.assertEqual(st1 < st3, not (st3 <= st1))
+ self.assertEqual(st2 < st3, not (st3 <= st2))
+ self.assertEqual(st1 < st2, st2 > st1)
+ self.assertEqual(st1 < st3, st3 > st1)
+ self.assertEqual(st2 < st3, st3 > st2)
+ self.assertEqual(st1 <= st2, st2 >= st1)
+ self.assertEqual(st3 <= st1, st1 >= st3)
+ self.assertEqual(st2 <= st3, st3 >= st2)
# transitivity
bottom = min(st1, st2, st3)
top = max(st1, st2, st3)
@@ -588,8 +588,8 @@
self.assertTrue(mid <= mid)
self.assertTrue(top <= top)
# interaction with other types
- self.assertEquals(st1 == 1588.602459, False)
- self.assertEquals('spanish armada' != st2, True)
+ self.assertEqual(st1 == 1588.602459, False)
+ self.assertEqual('spanish armada' != st2, True)
self.assertRaises(TypeError, operator.ge, st3, None)
self.assertRaises(TypeError, operator.le, False, st1)
self.assertRaises(TypeError, operator.lt, st1, 1815)
diff --git a/Lib/test/test_pep247.py b/Lib/test/test_pep247.py
index da8f816..7f10472 100644
--- a/Lib/test/test_pep247.py
+++ b/Lib/test/test_pep247.py
@@ -30,23 +30,23 @@
obj3 = cls()
obj3.update(b'string')
h2 = obj3.digest()
- self.assertEquals(h1, h2)
+ self.assertEqual(h1, h2)
self.assertTrue(hasattr(obj1, 'digest_size'))
if digest_size is not None:
- self.assertEquals(obj1.digest_size, digest_size)
+ self.assertEqual(obj1.digest_size, digest_size)
- self.assertEquals(obj1.digest_size, len(h1))
+ self.assertEqual(obj1.digest_size, len(h1))
obj1.update(b'string')
obj_copy = obj1.copy()
- self.assertEquals(obj1.digest(), obj_copy.digest())
- self.assertEquals(obj1.hexdigest(), obj_copy.hexdigest())
+ self.assertEqual(obj1.digest(), obj_copy.digest())
+ self.assertEqual(obj1.hexdigest(), obj_copy.hexdigest())
digest, hexdigest = obj1.digest(), obj1.hexdigest()
hd2 = ""
for byte in digest:
hd2 += '%02x' % byte
- self.assertEquals(hd2, hexdigest)
+ self.assertEqual(hd2, hexdigest)
def test_md5(self):
self.check_object(md5, None, None)
diff --git a/Lib/test/test_pep263.py b/Lib/test/test_pep263.py
index d5a5b3e..c159af9 100644
--- a/Lib/test/test_pep263.py
+++ b/Lib/test/test_pep263.py
@@ -26,7 +26,7 @@
try:
compile(b"# coding: cp932\nprint '\x94\x4e'", "dummy", "exec")
except SyntaxError as v:
- self.assertEquals(v.text, "print '\u5e74'")
+ self.assertEqual(v.text, "print '\u5e74'")
else:
self.fail()
@@ -34,7 +34,7 @@
c = compile("# coding=latin-1\n\u00c6 = '\u00c6'", "dummy", "exec")
d = {}
exec(c, d)
- self.assertEquals(d['\xc6'], '\xc6')
+ self.assertEqual(d['\xc6'], '\xc6')
def test_issue3297(self):
c = compile("a, b = '\U0001010F', '\\U0001010F'", "dummy", "exec")
diff --git a/Lib/test/test_pep3131.py b/Lib/test/test_pep3131.py
index e4c2d03..3d09ad1 100644
--- a/Lib/test/test_pep3131.py
+++ b/Lib/test/test_pep3131.py
@@ -9,15 +9,15 @@
ä = 1
µ = 2 # this is a compatibility character
蟒 = 3
- self.assertEquals(getattr(T, "\xe4"), 1)
- self.assertEquals(getattr(T, "\u03bc"), 2)
- self.assertEquals(getattr(T, '\u87d2'), 3)
+ self.assertEqual(getattr(T, "\xe4"), 1)
+ self.assertEqual(getattr(T, "\u03bc"), 2)
+ self.assertEqual(getattr(T, '\u87d2'), 3)
def test_invalid(self):
try:
from test import badsyntax_3131
except SyntaxError as s:
- self.assertEquals(str(s),
+ self.assertEqual(str(s),
"invalid character in identifier (badsyntax_3131.py, line 2)")
else:
self.fail("expected exception didn't occur")
diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py
index 466cbe3..4fd286a 100644
--- a/Lib/test/test_platform.py
+++ b/Lib/test/test_platform.py
@@ -155,17 +155,17 @@
# On Snow Leopard, sw_vers reports 10.6.0 as 10.6
if len_diff > 0:
expect_list.extend(['0'] * len_diff)
- self.assertEquals(result_list, expect_list)
+ self.assertEqual(result_list, expect_list)
# res[1] claims to contain
# (version, dev_stage, non_release_version)
# That information is no longer available
- self.assertEquals(res[1], ('', '', ''))
+ self.assertEqual(res[1], ('', '', ''))
if sys.byteorder == 'little':
- self.assertEquals(res[2], 'i386')
+ self.assertEqual(res[2], 'i386')
else:
- self.assertEquals(res[2], 'PowerPC')
+ self.assertEqual(res[2], 'PowerPC')
@unittest.skipUnless(sys.platform == 'darwin', "OSX only test")
@@ -183,8 +183,8 @@
else:
# parent
cpid, sts = os.waitpid(pid, 0)
- self.assertEquals(cpid, pid)
- self.assertEquals(sts, 0)
+ self.assertEqual(cpid, pid)
+ self.assertEqual(sts, 0)
def test_dist(self):
res = platform.dist()
diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py
index 60bb533..20b1066 100644
--- a/Lib/test/test_pow.py
+++ b/Lib/test/test_pow.py
@@ -5,17 +5,17 @@
def powtest(self, type):
if type != float:
for i in range(-1000, 1000):
- self.assertEquals(pow(type(i), 0), 1)
- self.assertEquals(pow(type(i), 1), type(i))
- self.assertEquals(pow(type(0), 1), type(0))
- self.assertEquals(pow(type(1), 1), type(1))
+ self.assertEqual(pow(type(i), 0), 1)
+ self.assertEqual(pow(type(i), 1), type(i))
+ self.assertEqual(pow(type(0), 1), type(0))
+ self.assertEqual(pow(type(1), 1), type(1))
for i in range(-100, 100):
- self.assertEquals(pow(type(i), 3), i*i*i)
+ self.assertEqual(pow(type(i), 3), i*i*i)
pow2 = 1
for i in range(0, 31):
- self.assertEquals(pow(2, i), pow2)
+ self.assertEqual(pow(2, i), pow2)
if i != 30 : pow2 = pow2*2
for othertype in (int,):
@@ -67,30 +67,30 @@
def test_other(self):
# Other tests-- not very systematic
- self.assertEquals(pow(3,3) % 8, pow(3,3,8))
- self.assertEquals(pow(3,3) % -8, pow(3,3,-8))
- self.assertEquals(pow(3,2) % -2, pow(3,2,-2))
- self.assertEquals(pow(-3,3) % 8, pow(-3,3,8))
- self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8))
- self.assertEquals(pow(5,2) % -8, pow(5,2,-8))
+ self.assertEqual(pow(3,3) % 8, pow(3,3,8))
+ self.assertEqual(pow(3,3) % -8, pow(3,3,-8))
+ self.assertEqual(pow(3,2) % -2, pow(3,2,-2))
+ self.assertEqual(pow(-3,3) % 8, pow(-3,3,8))
+ self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8))
+ self.assertEqual(pow(5,2) % -8, pow(5,2,-8))
- self.assertEquals(pow(3,3) % 8, pow(3,3,8))
- self.assertEquals(pow(3,3) % -8, pow(3,3,-8))
- self.assertEquals(pow(3,2) % -2, pow(3,2,-2))
- self.assertEquals(pow(-3,3) % 8, pow(-3,3,8))
- self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8))
- self.assertEquals(pow(5,2) % -8, pow(5,2,-8))
+ self.assertEqual(pow(3,3) % 8, pow(3,3,8))
+ self.assertEqual(pow(3,3) % -8, pow(3,3,-8))
+ self.assertEqual(pow(3,2) % -2, pow(3,2,-2))
+ self.assertEqual(pow(-3,3) % 8, pow(-3,3,8))
+ self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8))
+ self.assertEqual(pow(5,2) % -8, pow(5,2,-8))
for i in range(-10, 11):
for j in range(0, 6):
for k in range(-7, 11):
if j >= 0 and k != 0:
- self.assertEquals(
+ self.assertEqual(
pow(i,j) % k,
pow(i,j,k)
)
if j >= 0 and k != 0:
- self.assertEquals(
+ self.assertEqual(
pow(int(i),j) % k,
pow(int(i),j,k)
)
@@ -104,7 +104,7 @@
def test_bug705231(self):
# -1.0 raised to an integer should never blow up. It did if the
# platform pow() was buggy, and Python didn't worm around it.
- eq = self.assertEquals
+ eq = self.assertEqual
a = -1.0
# The next two tests can still fail if the platform floor()
# function doesn't treat all large inputs as integers
diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py
index e74ecd5..92039e4 100644
--- a/Lib/test/test_pty.py
+++ b/Lib/test/test_pty.py
@@ -86,7 +86,7 @@
fcntl.fcntl(master_fd, fcntl.F_SETFL, orig_flags | os.O_NONBLOCK)
try:
s1 = os.read(master_fd, 1024)
- self.assertEquals(b'', s1)
+ self.assertEqual(b'', s1)
except OSError as e:
if e.errno != errno.EAGAIN:
raise
@@ -96,14 +96,14 @@
debug("Writing to slave_fd")
os.write(slave_fd, TEST_STRING_1)
s1 = os.read(master_fd, 1024)
- self.assertEquals(b'I wish to buy a fish license.\n',
- normalize_output(s1))
+ self.assertEqual(b'I wish to buy a fish license.\n',
+ normalize_output(s1))
debug("Writing chunked output")
os.write(slave_fd, TEST_STRING_2[:5])
os.write(slave_fd, TEST_STRING_2[5:])
s2 = os.read(master_fd, 1024)
- self.assertEquals(b'For my pet fish, Eric.\n', normalize_output(s2))
+ self.assertEqual(b'For my pet fish, Eric.\n', normalize_output(s2))
os.close(slave_fd)
os.close(master_fd)
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index 30d8249..5b6fcb0 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -45,7 +45,7 @@
def assertEqualsOrIgnored(self, a, b, ignore):
''' succeed iff a == b or a in ignore or b in ignore '''
if a not in ignore and b not in ignore:
- self.assertEquals(a, b)
+ self.assertEqual(a, b)
def checkModule(self, moduleName, module=None, ignore=()):
''' succeed iff pyclbr.readmodule_ex(modulename) corresponds
@@ -87,7 +87,7 @@
self.assertTrue(isinstance(py_item, (FunctionType, BuiltinFunctionType)))
if py_item.__module__ != moduleName:
continue # skip functions that came from somewhere else
- self.assertEquals(py_item.__module__, value.module)
+ self.assertEqual(py_item.__module__, value.module)
else:
self.assertTrue(isinstance(py_item, type))
if py_item.__module__ != moduleName:
@@ -116,7 +116,7 @@
try:
self.assertListEq(foundMethods, actualMethods, ignore)
- self.assertEquals(py_item.__module__, value.module)
+ self.assertEqual(py_item.__module__, value.module)
self.assertEqualsOrIgnored(py_item.__name__, value.name,
ignore)
diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index 5ac2a47..133c02b 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -24,12 +24,12 @@
def test_ordered_attributes(self):
for x, y in self.set_get_pairs:
self.parser.ordered_attributes = x
- self.assertEquals(self.parser.ordered_attributes, y)
+ self.assertEqual(self.parser.ordered_attributes, y)
def test_specified_attributes(self):
for x, y in self.set_get_pairs:
self.parser.specified_attributes = x
- self.assertEquals(self.parser.specified_attributes, y)
+ self.assertEqual(self.parser.specified_attributes, y)
data = b'''\
@@ -127,23 +127,23 @@
]
def _verify_parse_output(self, op):
- self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
- self.assertEquals(op[1], "Comment: ' comment data '")
- self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
- self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
- self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\u1f40'}")
- self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
- self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
- self.assertEquals(op[7], "Character data: 'Contents of subelements'")
- self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'")
- self.assertEquals(op[9], "End of NS decl: 'myns'")
- self.assertEquals(op[10], "Start element: 'sub2' {}")
- self.assertEquals(op[11], 'Start of CDATA section')
- self.assertEquals(op[12], "Character data: 'contents of CDATA section'")
- self.assertEquals(op[13], 'End of CDATA section')
- self.assertEquals(op[14], "End element: 'sub2'")
- self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)")
- self.assertEquals(op[16], "End element: 'root'")
+ self.assertEqual(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'')
+ self.assertEqual(op[1], "Comment: ' comment data '")
+ self.assertEqual(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)")
+ self.assertEqual(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')")
+ self.assertEqual(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\u1f40'}")
+ self.assertEqual(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'")
+ self.assertEqual(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}")
+ self.assertEqual(op[7], "Character data: 'Contents of subelements'")
+ self.assertEqual(op[8], "End element: 'http://www.python.org/namespace!subelement'")
+ self.assertEqual(op[9], "End of NS decl: 'myns'")
+ self.assertEqual(op[10], "Start element: 'sub2' {}")
+ self.assertEqual(op[11], 'Start of CDATA section')
+ self.assertEqual(op[12], "Character data: 'contents of CDATA section'")
+ self.assertEqual(op[13], 'End of CDATA section')
+ self.assertEqual(op[14], "End element: 'sub2'")
+ self.assertEqual(op[15], "External entity ref: (None, 'entity.file', None)")
+ self.assertEqual(op[16], "End element: 'root'")
def test_unicode(self):
@@ -184,14 +184,14 @@
expat.ParserCreate(namespace_separator=42)
self.fail()
except TypeError as e:
- self.assertEquals(str(e),
+ self.assertEqual(str(e),
'ParserCreate() argument 2 must be string or None, not int')
try:
expat.ParserCreate(namespace_separator='too long')
self.fail()
except ValueError as e:
- self.assertEquals(str(e),
+ self.assertEqual(str(e),
'namespace_separator must be at most one character, omitted, or None')
def test_zero_length(self):
@@ -217,7 +217,7 @@
p.EndElementHandler = collector
p.Parse("<e> <e/> <e></e> </e>", 1)
tag = L[0]
- self.assertEquals(len(L), 6)
+ self.assertEqual(len(L), 6)
for entry in L:
# L should have the same string repeated over and over.
self.assertTrue(tag is entry)
@@ -231,7 +231,7 @@
self.parser.CharacterDataHandler = self.CharacterDataHandler
def check(self, expected, label):
- self.assertEquals(self.stuff, expected,
+ self.assertEqual(self.stuff, expected,
"%s\nstuff = %r\nexpected = %r"
% (label, self.stuff, map(str, expected)))
@@ -264,47 +264,47 @@
# Make sure buffering is turned on
self.assertTrue(self.parser.buffer_text)
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
- self.assertEquals(self.stuff, ['123'],
- "buffered text not properly collapsed")
+ self.assertEqual(self.stuff, ['123'],
+ "buffered text not properly collapsed")
def test1(self):
# XXX This test exposes more detail of Expat's text chunking than we
# XXX like, but it tests what we need to concisely.
self.setHandlers(["StartElementHandler"])
self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1)
- self.assertEquals(self.stuff,
- ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
- "buffering control not reacting as expected")
+ self.assertEqual(self.stuff,
+ ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
+ "buffering control not reacting as expected")
def test2(self):
self.parser.Parse("<a>1<b/><2><c/> \n 3</a>", 1)
- self.assertEquals(self.stuff, ["1<2> \n 3"],
- "buffered text not properly collapsed")
+ self.assertEqual(self.stuff, ["1<2> \n 3"],
+ "buffered text not properly collapsed")
def test3(self):
self.setHandlers(["StartElementHandler"])
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
- self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
- "buffered text not properly split")
+ self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
+ "buffered text not properly split")
def test4(self):
self.setHandlers(["StartElementHandler", "EndElementHandler"])
self.parser.CharacterDataHandler = None
self.parser.Parse("<a>1<b/>2<c/>3</a>", 1)
- self.assertEquals(self.stuff,
- ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
+ self.assertEqual(self.stuff,
+ ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
def test5(self):
self.setHandlers(["StartElementHandler", "EndElementHandler"])
self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1)
- self.assertEquals(self.stuff,
+ self.assertEqual(self.stuff,
["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
def test6(self):
self.setHandlers(["CommentHandler", "EndElementHandler",
"StartElementHandler"])
self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1)
- self.assertEquals(self.stuff,
+ self.assertEqual(self.stuff,
["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
"buffered text not properly split")
@@ -312,10 +312,10 @@
self.setHandlers(["CommentHandler", "EndElementHandler",
"StartElementHandler"])
self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1)
- self.assertEquals(self.stuff,
- ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
- "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
- "buffered text not properly split")
+ self.assertEqual(self.stuff,
+ ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3",
+ "<!--abc-->", "4", "<!--def-->", "5", "</a>"],
+ "buffered text not properly split")
# Test handling of exception from callback:
@@ -330,9 +330,9 @@
parser.Parse("<a><b><c/></b></a>", 1)
self.fail()
except RuntimeError as e:
- self.assertEquals(e.args[0], 'a',
- "Expected RuntimeError for element 'a', but" + \
- " found %r" % e.args[0])
+ self.assertEqual(e.args[0], 'a',
+ "Expected RuntimeError for element 'a', but" + \
+ " found %r" % e.args[0])
# Test Current* members:
@@ -351,7 +351,7 @@
self.assertTrue(self.upto < len(self.expected_list),
'too many parser events')
expected = self.expected_list[self.upto]
- self.assertEquals(pos, expected,
+ self.assertEqual(pos, expected,
'Expected position %s, got position %s' %(pos, expected))
self.upto += 1
@@ -392,10 +392,10 @@
"""
def test_1025_bytes(self):
- self.assertEquals(self.small_buffer_test(1025), 2)
+ self.assertEqual(self.small_buffer_test(1025), 2)
def test_1000_bytes(self):
- self.assertEquals(self.small_buffer_test(1000), 1)
+ self.assertEqual(self.small_buffer_test(1000), 1)
def test_wrong_size(self):
parser = expat.ParserCreate()
@@ -418,15 +418,15 @@
# once.
self.n = 0
parser.Parse(xml1)
- self.assertEquals(self.n, 1)
+ self.assertEqual(self.n, 1)
# Reassign to buffer_size, but assign the same size.
parser.buffer_size = parser.buffer_size
- self.assertEquals(self.n, 1)
+ self.assertEqual(self.n, 1)
# Try parsing rest of the document
parser.Parse(xml2)
- self.assertEquals(self.n, 2)
+ self.assertEqual(self.n, 2)
def test_disabling_buffer(self):
@@ -437,27 +437,27 @@
parser.CharacterDataHandler = self.counting_handler
parser.buffer_text = 1
parser.buffer_size = 1024
- self.assertEquals(parser.buffer_size, 1024)
+ self.assertEqual(parser.buffer_size, 1024)
# Parse one chunk of XML
self.n = 0
parser.Parse(xml1, 0)
- self.assertEquals(parser.buffer_size, 1024)
- self.assertEquals(self.n, 1)
+ self.assertEqual(parser.buffer_size, 1024)
+ self.assertEqual(self.n, 1)
# Turn off buffering and parse the next chunk.
parser.buffer_text = 0
self.assertFalse(parser.buffer_text)
- self.assertEquals(parser.buffer_size, 1024)
+ self.assertEqual(parser.buffer_size, 1024)
for i in range(10):
parser.Parse(xml2, 0)
- self.assertEquals(self.n, 11)
+ self.assertEqual(self.n, 11)
parser.buffer_text = 1
self.assertTrue(parser.buffer_text)
- self.assertEquals(parser.buffer_size, 1024)
+ self.assertEqual(parser.buffer_size, 1024)
parser.Parse(xml3, 1)
- self.assertEquals(self.n, 12)
+ self.assertEqual(self.n, 12)
@@ -485,14 +485,14 @@
parser.CharacterDataHandler = self.counting_handler
parser.buffer_text = 1
parser.buffer_size = 1024
- self.assertEquals(parser.buffer_size, 1024)
+ self.assertEqual(parser.buffer_size, 1024)
self.n = 0
parser.Parse(xml1, 0)
parser.buffer_size *= 2
- self.assertEquals(parser.buffer_size, 2048)
+ self.assertEqual(parser.buffer_size, 2048)
parser.Parse(xml2, 1)
- self.assertEquals(self.n, 2)
+ self.assertEqual(self.n, 2)
def test_change_size_2(self):
xml1 = "<?xml version='1.0' encoding='iso8859'?><a>a<s>%s" % ('a' * 1023)
@@ -501,14 +501,14 @@
parser.CharacterDataHandler = self.counting_handler
parser.buffer_text = 1
parser.buffer_size = 2048
- self.assertEquals(parser.buffer_size, 2048)
+ self.assertEqual(parser.buffer_size, 2048)
self.n=0
parser.Parse(xml1, 0)
parser.buffer_size = parser.buffer_size // 2
- self.assertEquals(parser.buffer_size, 1024)
+ self.assertEqual(parser.buffer_size, 1024)
parser.Parse(xml2, 1)
- self.assertEquals(self.n, 4)
+ self.assertEqual(self.n, 4)
class MalformedInputText(unittest.TestCase):
def test1(self):
@@ -518,7 +518,7 @@
parser.Parse(xml, True)
self.fail()
except expat.ExpatError as e:
- self.assertEquals(str(e), 'unclosed token: line 2, column 0')
+ self.assertEqual(str(e), 'unclosed token: line 2, column 0')
def test2(self):
xml = "<?xml version\xc2\x85='1.0'?>\r\n"
@@ -527,7 +527,7 @@
parser.Parse(xml, True)
self.fail()
except expat.ExpatError as e:
- self.assertEquals(str(e), 'XML declaration not well-formed: line 1, column 14')
+ self.assertEqual(str(e), 'XML declaration not well-formed: line 1, column 14')
def test_main():
run_unittest(SetAttributeTest,
diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py
index 95f80ac..c65827d 100644
--- a/Lib/test/test_queue.py
+++ b/Lib/test/test_queue.py
@@ -99,8 +99,8 @@
LifoQueue = [222, 333, 111],
PriorityQueue = [111, 222, 333])
actual_order = [q.get(), q.get(), q.get()]
- self.assertEquals(actual_order, target_order[q.__class__.__name__],
- "Didn't seem to queue the correct data!")
+ self.assertEqual(actual_order, target_order[q.__class__.__name__],
+ "Didn't seem to queue the correct data!")
for i in range(QUEUE_SIZE-1):
q.put(i)
self.assertTrue(q.qsize(), "Queue should not be empty")
@@ -158,8 +158,8 @@
for i in range(100):
q.put(i)
q.join()
- self.assertEquals(self.cum, sum(range(100)),
- "q.join() did not block until all tasks were done")
+ self.assertEqual(self.cum, sum(range(100)),
+ "q.join() did not block until all tasks were done")
for i in (0,1):
q.put(-1) # instruct the threads to close
q.join() # verify that you can join twice
diff --git a/Lib/test/test_range.py b/Lib/test/test_range.py
index ba028a6..c082fd1 100644
--- a/Lib/test/test_range.py
+++ b/Lib/test/test_range.py
@@ -105,8 +105,8 @@
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
for t in testcases:
r = range(*t)
- self.assertEquals(list(pickle.loads(pickle.dumps(r, proto))),
- list(r))
+ self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))),
+ list(r))
def test_odd_bug(self):
# This used to raise a "SystemError: NULL result without error"
diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
index 12e207b..ce6ecb6 100644
--- a/Lib/test/test_reprlib.py
+++ b/Lib/test/test_reprlib.py
@@ -22,7 +22,7 @@
class ReprTests(unittest.TestCase):
def test_string(self):
- eq = self.assertEquals
+ eq = self.assertEqual
eq(r("abc"), "'abc'")
eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'")
@@ -36,7 +36,7 @@
eq(r(s), expected)
def test_tuple(self):
- eq = self.assertEquals
+ eq = self.assertEqual
eq(r((1,)), "(1,)")
t3 = (1, 2, 3)
@@ -51,7 +51,7 @@
from array import array
from collections import deque
- eq = self.assertEquals
+ eq = self.assertEqual
# Tuples give up after 6 elements
eq(r(()), "()")
eq(r((1,)), "(1,)")
@@ -101,7 +101,7 @@
"array('i', [1, 2, 3, 4, 5, ...])")
def test_numbers(self):
- eq = self.assertEquals
+ eq = self.assertEqual
eq(r(123), repr(123))
eq(r(123), repr(123))
eq(r(1.0/3), repr(1.0/3))
@@ -111,7 +111,7 @@
eq(r(n), expected)
def test_instance(self):
- eq = self.assertEquals
+ eq = self.assertEqual
i1 = ClassWithRepr("a")
eq(r(i1), repr(i1))
@@ -133,7 +133,7 @@
# XXX anonymous functions? see func_repr
def test_builtin_function(self):
- eq = self.assertEquals
+ eq = self.assertEqual
# Functions
eq(repr(hash), '<built-in function hash>')
# Methods
@@ -141,13 +141,13 @@
'<built-in method split of str object at 0x'))
def test_range(self):
- eq = self.assertEquals
+ eq = self.assertEqual
eq(repr(range(1)), 'range(0, 1)')
eq(repr(range(1, 2)), 'range(1, 2)')
eq(repr(range(1, 4, 3)), 'range(1, 4, 3)')
def test_nesting(self):
- eq = self.assertEquals
+ eq = self.assertEqual
# everything is meant to give up after 6 levels.
eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]")
eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]")
@@ -168,7 +168,7 @@
pass
def test_descriptors(self):
- eq = self.assertEquals
+ eq = self.assertEqual
# method descriptors
eq(repr(dict.items), "<method 'items' of 'dict' objects>")
# XXX member descriptors
@@ -229,7 +229,7 @@
del sys.path[0]
def test_module(self):
- eq = self.assertEquals
+ eq = self.assertEqual
touch(os.path.join(self.subpkgname, self.pkgname + '.py'))
from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation
eq(repr(areallylongpackageandmodulenametotestreprtruncation),
@@ -237,7 +237,7 @@
eq(repr(sys), "<module 'sys' (built-in)>")
def test_type(self):
- eq = self.assertEquals
+ eq = self.assertEqual
touch(os.path.join(self.subpkgname, 'foo.py'), '''\
class foo(object):
pass
@@ -258,7 +258,7 @@
''')
from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar
# Module name may be prefixed with "test.", depending on how run.
- self.assertEquals(repr(bar.bar), "<class '%s.bar'>" % bar.__name__)
+ self.assertEqual(repr(bar.bar), "<class '%s.bar'>" % bar.__name__)
def test_instance(self):
touch(os.path.join(self.subpkgname, 'baz.py'), '''\
@@ -271,7 +271,7 @@
"<%s.baz object at 0x" % baz.__name__))
def test_method(self):
- eq = self.assertEquals
+ eq = self.assertEqual
touch(os.path.join(self.subpkgname, 'qux.py'), '''\
class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:
def amethod(self): pass
diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py
index c8c7b3a..6c9147a 100644
--- a/Lib/test/test_sax.py
+++ b/Lib/test/test_sax.py
@@ -27,16 +27,16 @@
self.assertRaises(KeyError, attrs.getNameByQName, "attr")
self.assertRaises(KeyError, attrs.getQNameByName, "attr")
self.assertRaises(KeyError, attrs.__getitem__, "attr")
- self.assertEquals(attrs.getLength(), 0)
- self.assertEquals(attrs.getNames(), [])
- self.assertEquals(attrs.getQNames(), [])
- self.assertEquals(len(attrs), 0)
+ self.assertEqual(attrs.getLength(), 0)
+ self.assertEqual(attrs.getNames(), [])
+ self.assertEqual(attrs.getQNames(), [])
+ self.assertEqual(len(attrs), 0)
self.assertFalse("attr" in attrs)
- self.assertEquals(list(attrs.keys()), [])
- self.assertEquals(attrs.get("attrs"), None)
- self.assertEquals(attrs.get("attrs", 25), 25)
- self.assertEquals(list(attrs.items()), [])
- self.assertEquals(list(attrs.values()), [])
+ self.assertEqual(list(attrs.keys()), [])
+ self.assertEqual(attrs.get("attrs"), None)
+ self.assertEqual(attrs.get("attrs", 25), 25)
+ self.assertEqual(list(attrs.items()), [])
+ self.assertEqual(list(attrs.values()), [])
def verify_empty_nsattrs(self, attrs):
self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
@@ -44,33 +44,33 @@
self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
- self.assertEquals(attrs.getLength(), 0)
- self.assertEquals(attrs.getNames(), [])
- self.assertEquals(attrs.getQNames(), [])
- self.assertEquals(len(attrs), 0)
+ self.assertEqual(attrs.getLength(), 0)
+ self.assertEqual(attrs.getNames(), [])
+ self.assertEqual(attrs.getQNames(), [])
+ self.assertEqual(len(attrs), 0)
self.assertFalse((ns_uri, "attr") in attrs)
- self.assertEquals(list(attrs.keys()), [])
- self.assertEquals(attrs.get((ns_uri, "attr")), None)
- self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25)
- self.assertEquals(list(attrs.items()), [])
- self.assertEquals(list(attrs.values()), [])
+ self.assertEqual(list(attrs.keys()), [])
+ self.assertEqual(attrs.get((ns_uri, "attr")), None)
+ self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25)
+ self.assertEqual(list(attrs.items()), [])
+ self.assertEqual(list(attrs.values()), [])
def verify_attrs_wattr(self, attrs):
- self.assertEquals(attrs.getLength(), 1)
- self.assertEquals(attrs.getNames(), ["attr"])
- self.assertEquals(attrs.getQNames(), ["attr"])
- self.assertEquals(len(attrs), 1)
+ self.assertEqual(attrs.getLength(), 1)
+ self.assertEqual(attrs.getNames(), ["attr"])
+ self.assertEqual(attrs.getQNames(), ["attr"])
+ self.assertEqual(len(attrs), 1)
self.assertTrue("attr" in attrs)
- self.assertEquals(list(attrs.keys()), ["attr"])
- self.assertEquals(attrs.get("attr"), "val")
- self.assertEquals(attrs.get("attr", 25), "val")
- self.assertEquals(list(attrs.items()), [("attr", "val")])
- self.assertEquals(list(attrs.values()), ["val"])
- self.assertEquals(attrs.getValue("attr"), "val")
- self.assertEquals(attrs.getValueByQName("attr"), "val")
- self.assertEquals(attrs.getNameByQName("attr"), "attr")
- self.assertEquals(attrs["attr"], "val")
- self.assertEquals(attrs.getQNameByName("attr"), "attr")
+ self.assertEqual(list(attrs.keys()), ["attr"])
+ self.assertEqual(attrs.get("attr"), "val")
+ self.assertEqual(attrs.get("attr", 25), "val")
+ self.assertEqual(list(attrs.items()), [("attr", "val")])
+ self.assertEqual(list(attrs.values()), ["val"])
+ self.assertEqual(attrs.getValue("attr"), "val")
+ self.assertEqual(attrs.getValueByQName("attr"), "val")
+ self.assertEqual(attrs.getNameByQName("attr"), "attr")
+ self.assertEqual(attrs["attr"], "val")
+ self.assertEqual(attrs.getQNameByName("attr"), "attr")
class MakeParserTest(unittest.TestCase):
def test_make_parser2(self):
@@ -100,46 +100,46 @@
class SaxutilsTest(unittest.TestCase):
# ===== escape
def test_escape_basic(self):
- self.assertEquals(escape("Donald Duck & Co"), "Donald Duck & Co")
+ self.assertEqual(escape("Donald Duck & Co"), "Donald Duck & Co")
def test_escape_all(self):
- self.assertEquals(escape("<Donald Duck & Co>"),
- "<Donald Duck & Co>")
+ self.assertEqual(escape("<Donald Duck & Co>"),
+ "<Donald Duck & Co>")
def test_escape_extra(self):
- self.assertEquals(escape("Hei på deg", {"å" : "å"}),
- "Hei på deg")
+ self.assertEqual(escape("Hei på deg", {"å" : "å"}),
+ "Hei på deg")
# ===== unescape
def test_unescape_basic(self):
- self.assertEquals(unescape("Donald Duck & Co"), "Donald Duck & Co")
+ self.assertEqual(unescape("Donald Duck & Co"), "Donald Duck & Co")
def test_unescape_all(self):
- self.assertEquals(unescape("<Donald Duck & Co>"),
- "<Donald Duck & Co>")
+ self.assertEqual(unescape("<Donald Duck & Co>"),
+ "<Donald Duck & Co>")
def test_unescape_extra(self):
- self.assertEquals(unescape("Hei på deg", {"å" : "å"}),
- "Hei på deg")
+ self.assertEqual(unescape("Hei på deg", {"å" : "å"}),
+ "Hei på deg")
def test_unescape_amp_extra(self):
- self.assertEquals(unescape("&foo;", {"&foo;": "splat"}), "&foo;")
+ self.assertEqual(unescape("&foo;", {"&foo;": "splat"}), "&foo;")
# ===== quoteattr
def test_quoteattr_basic(self):
- self.assertEquals(quoteattr("Donald Duck & Co"),
- '"Donald Duck & Co"')
+ self.assertEqual(quoteattr("Donald Duck & Co"),
+ '"Donald Duck & Co"')
def test_single_quoteattr(self):
- self.assertEquals(quoteattr('Includes "double" quotes'),
- '\'Includes "double" quotes\'')
+ self.assertEqual(quoteattr('Includes "double" quotes'),
+ '\'Includes "double" quotes\'')
def test_double_quoteattr(self):
- self.assertEquals(quoteattr("Includes 'single' quotes"),
- "\"Includes 'single' quotes\"")
+ self.assertEqual(quoteattr("Includes 'single' quotes"),
+ "\"Includes 'single' quotes\"")
def test_single_double_quoteattr(self):
- self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"),
+ self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"),
"\"Includes 'single' and "double" quotes\"")
# ===== make_parser
@@ -162,7 +162,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(), start + "<doc></doc>")
+ self.assertEqual(result.getvalue(), start + "<doc></doc>")
def test_xmlgen_content(self):
result = StringIO()
@@ -174,7 +174,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>")
+ self.assertEqual(result.getvalue(), start + "<doc>huhei</doc>")
def test_xmlgen_pi(self):
result = StringIO()
@@ -186,7 +186,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>")
+ self.assertEqual(result.getvalue(), start + "<?test data?><doc></doc>")
def test_xmlgen_content_escape(self):
result = StringIO()
@@ -198,7 +198,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(),
+ self.assertEqual(result.getvalue(),
start + "<doc><huhei&</doc>")
def test_xmlgen_attr_escape(self):
@@ -216,7 +216,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(), start +
+ self.assertEqual(result.getvalue(), start +
("<doc a='\"'><e a=\"'\"></e>"
"<e a=\"'"\"></e>"
"<e a=\" 	\"></e></doc>"))
@@ -231,7 +231,7 @@
gen.endElement("doc")
gen.endDocument()
- self.assertEquals(result.getvalue(), start + "<doc> </doc>")
+ self.assertEqual(result.getvalue(), start + "<doc> </doc>")
def test_xmlgen_ns(self):
result = StringIO()
@@ -247,7 +247,7 @@
gen.endPrefixMapping("ns1")
gen.endDocument()
- self.assertEquals(result.getvalue(), start + \
+ self.assertEqual(result.getvalue(), start + \
('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
ns_uri))
@@ -260,7 +260,7 @@
gen.endElementNS((None, 'a'), 'a')
gen.endDocument()
- self.assertEquals(result.getvalue(), start+'<a b="c"></a>')
+ self.assertEqual(result.getvalue(), start+'<a b="c"></a>')
def test_1463026_2(self):
result = StringIO()
@@ -273,7 +273,7 @@
gen.endPrefixMapping(None)
gen.endDocument()
- self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>')
+ self.assertEqual(result.getvalue(), start+'<a xmlns="qux"></a>')
def test_1463026_3(self):
result = StringIO()
@@ -286,7 +286,7 @@
gen.endPrefixMapping('my')
gen.endDocument()
- self.assertEquals(result.getvalue(),
+ self.assertEqual(result.getvalue(),
start+'<my:a xmlns:my="qux" b="c"></my:a>')
def test_5027_1(self):
@@ -309,11 +309,11 @@
parser.setContentHandler(gen)
parser.parse(test_xml)
- self.assertEquals(result.getvalue(),
- start + (
- '<a:g1 xmlns:a="http://example.com/ns">'
- '<a:g2 xml:lang="en">Hello</a:g2>'
- '</a:g1>'))
+ self.assertEqual(result.getvalue(),
+ start + (
+ '<a:g1 xmlns:a="http://example.com/ns">'
+ '<a:g2 xml:lang="en">Hello</a:g2>'
+ '</a:g1>'))
def test_5027_2(self):
# The xml prefix (as in xml:lang below) is reserved and bound by
@@ -337,11 +337,11 @@
gen.endPrefixMapping('a')
gen.endDocument()
- self.assertEquals(result.getvalue(),
- start + (
- '<a:g1 xmlns:a="http://example.com/ns">'
- '<a:g2 xml:lang="en">Hello</a:g2>'
- '</a:g1>'))
+ self.assertEqual(result.getvalue(),
+ start + (
+ '<a:g1 xmlns:a="http://example.com/ns">'
+ '<a:g2 xml:lang="en">Hello</a:g2>'
+ '</a:g1>'))
class XMLFilterBaseTest(unittest.TestCase):
@@ -358,7 +358,7 @@
filter.endElement("doc")
filter.endDocument()
- self.assertEquals(result.getvalue(), start + "<doc>content </doc>")
+ self.assertEqual(result.getvalue(), start + "<doc>content </doc>")
# ===========================================================================
#
@@ -380,7 +380,7 @@
parser.setContentHandler(xmlgen)
parser.parse(open(findfile("test.xml")))
- self.assertEquals(result.getvalue(), xml_test_out)
+ self.assertEqual(result.getvalue(), xml_test_out)
# ===== DTDHandler support
@@ -408,9 +408,9 @@
parser.feed('<doc></doc>')
parser.close()
- self.assertEquals(handler._notations,
+ self.assertEqual(handler._notations,
[("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
- self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")])
+ self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")])
# ===== EntityResolver support
@@ -433,8 +433,8 @@
parser.feed('<doc>&test;</doc>')
parser.close()
- self.assertEquals(result.getvalue(), start +
- "<doc><entity></entity></doc>")
+ self.assertEqual(result.getvalue(), start +
+ "<doc><entity></entity></doc>")
# ===== Attributes support
@@ -486,18 +486,18 @@
attrs = gather._attrs
- self.assertEquals(attrs.getLength(), 1)
- self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
+ self.assertEqual(attrs.getLength(), 1)
+ self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
self.assertTrue((attrs.getQNames() == [] or
attrs.getQNames() == ["ns:attr"]))
- self.assertEquals(len(attrs), 1)
+ self.assertEqual(len(attrs), 1)
self.assertTrue((ns_uri, "attr") in attrs)
- self.assertEquals(attrs.get((ns_uri, "attr")), "val")
- self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
- self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")])
- self.assertEquals(list(attrs.values()), ["val"])
- self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
- self.assertEquals(attrs[(ns_uri, "attr")], "val")
+ self.assertEqual(attrs.get((ns_uri, "attr")), "val")
+ self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
+ self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
+ self.assertEqual(list(attrs.values()), ["val"])
+ self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
+ self.assertEqual(attrs[(ns_uri, "attr")], "val")
# ===== InputSource support
@@ -509,7 +509,7 @@
parser.setContentHandler(xmlgen)
parser.parse(findfile("test.xml"))
- self.assertEquals(result.getvalue(), xml_test_out)
+ self.assertEqual(result.getvalue(), xml_test_out)
def test_expat_inpsource_sysid(self):
parser = create_parser()
@@ -519,7 +519,7 @@
parser.setContentHandler(xmlgen)
parser.parse(InputSource(findfile("test.xml")))
- self.assertEquals(result.getvalue(), xml_test_out)
+ self.assertEqual(result.getvalue(), xml_test_out)
def test_expat_inpsource_stream(self):
parser = create_parser()
@@ -531,7 +531,7 @@
inpsrc.setByteStream(open(findfile("test.xml")))
parser.parse(inpsrc)
- self.assertEquals(result.getvalue(), xml_test_out)
+ self.assertEqual(result.getvalue(), xml_test_out)
# ===== IncrementalParser support
@@ -545,7 +545,7 @@
parser.feed("</doc>")
parser.close()
- self.assertEquals(result.getvalue(), start + "<doc></doc>")
+ self.assertEqual(result.getvalue(), start + "<doc></doc>")
def test_expat_incremental_reset(self):
result = StringIO()
@@ -566,7 +566,7 @@
parser.feed("</doc>")
parser.close()
- self.assertEquals(result.getvalue(), start + "<doc>text</doc>")
+ self.assertEqual(result.getvalue(), start + "<doc>text</doc>")
# ===== Locator support
@@ -580,9 +580,9 @@
parser.feed("</doc>")
parser.close()
- self.assertEquals(parser.getSystemId(), None)
- self.assertEquals(parser.getPublicId(), None)
- self.assertEquals(parser.getLineNumber(), 1)
+ self.assertEqual(parser.getSystemId(), None)
+ self.assertEqual(parser.getPublicId(), None)
+ self.assertEqual(parser.getLineNumber(), 1)
def test_expat_locator_withinfo(self):
result = StringIO()
@@ -591,8 +591,8 @@
parser.setContentHandler(xmlgen)
parser.parse(findfile("test.xml"))
- self.assertEquals(parser.getSystemId(), findfile("test.xml"))
- self.assertEquals(parser.getPublicId(), None)
+ self.assertEqual(parser.getSystemId(), findfile("test.xml"))
+ self.assertEqual(parser.getPublicId(), None)
# ===========================================================================
@@ -613,7 +613,7 @@
parser.parse(source)
self.fail()
except SAXException as e:
- self.assertEquals(e.getSystemId(), name)
+ self.assertEqual(e.getSystemId(), name)
def test_expat_incomplete(self):
parser = create_parser()
@@ -677,21 +677,21 @@
attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
{(ns_uri, "attr") : "ns:attr"})
- self.assertEquals(attrs.getLength(), 1)
- self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
- self.assertEquals(attrs.getQNames(), ["ns:attr"])
- self.assertEquals(len(attrs), 1)
+ self.assertEqual(attrs.getLength(), 1)
+ self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
+ self.assertEqual(attrs.getQNames(), ["ns:attr"])
+ self.assertEqual(len(attrs), 1)
self.assertTrue((ns_uri, "attr") in attrs)
- self.assertEquals(list(attrs.keys()), [(ns_uri, "attr")])
- self.assertEquals(attrs.get((ns_uri, "attr")), "val")
- self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
- self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")])
- self.assertEquals(list(attrs.values()), ["val"])
- self.assertEquals(attrs.getValue((ns_uri, "attr")), "val")
- self.assertEquals(attrs.getValueByQName("ns:attr"), "val")
- self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
- self.assertEquals(attrs[(ns_uri, "attr")], "val")
- self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
+ self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")])
+ self.assertEqual(attrs.get((ns_uri, "attr")), "val")
+ self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
+ self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
+ self.assertEqual(list(attrs.values()), ["val"])
+ self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
+ self.assertEqual(attrs.getValueByQName("ns:attr"), "val")
+ self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
+ self.assertEqual(attrs[(ns_uri, "attr")], "val")
+ self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
# During the development of Python 2.5, an attempt to move the "xml"
@@ -727,7 +727,7 @@
try:
import xml.sax.expatreader
module = xml.sax.expatreader
- self.assertEquals(module.__name__, "xml.sax.expatreader")
+ self.assertEqual(module.__name__, "xml.sax.expatreader")
finally:
sys.modules.update(old_modules)
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 5f8768a..fb97f1b 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -498,7 +498,7 @@
def f(self):
return x
- self.assertEquals(x, 12) # Used to raise UnboundLocalError
+ self.assertEqual(x, 12) # Used to raise UnboundLocalError
finally:
sys.settrace(None)
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index 83ac669..8f9b064 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -203,10 +203,10 @@
def test_getsignal(self):
hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler)
- self.assertEquals(signal.getsignal(signal.SIGHUP),
- self.trivial_signal_handler)
+ self.assertEqual(signal.getsignal(signal.SIGHUP),
+ self.trivial_signal_handler)
signal.signal(signal.SIGHUP, hup)
- self.assertEquals(signal.getsignal(signal.SIGHUP), hup)
+ self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
@unittest.skipUnless(sys.platform == "win32", "Windows specific")
@@ -456,9 +456,9 @@
"high")
# virtual itimer should be (0.0, 0.0) now
- self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0))
+ self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
# and the handler should have been called
- self.assertEquals(self.hndl_called, True)
+ self.assertEqual(self.hndl_called, True)
# Issue 3864, unknown if this affects earlier versions of freebsd also
@unittest.skipIf(sys.platform=='freebsd6',
@@ -479,7 +479,7 @@
"high")
# profiling itimer should be (0.0, 0.0) now
- self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0))
+ self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
# and the handler should have been called
self.assertEqual(self.hndl_called, True)
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index 2ecb59a..2df9271 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -118,7 +118,7 @@
x = X()
x[1:2] = 42
- self.assertEquals(tmp, [(slice(1, 2), 42)])
+ self.assertEqual(tmp, [(slice(1, 2), 42)])
def test_pickle(self):
s = slice(10, 20, 3)
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 98ba4df..0bb43d3 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -425,8 +425,8 @@
return # No inet_aton, nothing to check
# Test that issue1008086 and issue767150 are fixed.
# It must return 4 bytes.
- self.assertEquals(b'\x00'*4, socket.inet_aton('0.0.0.0'))
- self.assertEquals(b'\xff'*4, socket.inet_aton('255.255.255.255'))
+ self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
+ self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
def testIPv4toString(self):
if not hasattr(socket, 'inet_pton'):
@@ -434,16 +434,16 @@
from socket import inet_aton as f, inet_pton, AF_INET
g = lambda a: inet_pton(AF_INET, a)
- self.assertEquals(b'\x00\x00\x00\x00', f('0.0.0.0'))
- self.assertEquals(b'\xff\x00\xff\x00', f('255.0.255.0'))
- self.assertEquals(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
- self.assertEquals(b'\x01\x02\x03\x04', f('1.2.3.4'))
- self.assertEquals(b'\xff\xff\xff\xff', f('255.255.255.255'))
+ self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0'))
+ self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0'))
+ self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
+ self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4'))
+ self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255'))
- self.assertEquals(b'\x00\x00\x00\x00', g('0.0.0.0'))
- self.assertEquals(b'\xff\x00\xff\x00', g('255.0.255.0'))
- self.assertEquals(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
- self.assertEquals(b'\xff\xff\xff\xff', g('255.255.255.255'))
+ self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0'))
+ self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0'))
+ self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
+ self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255'))
def testIPv6toString(self):
if not hasattr(socket, 'inet_pton'):
@@ -456,10 +456,10 @@
return
f = lambda a: inet_pton(AF_INET6, a)
- self.assertEquals(b'\x00' * 16, f('::'))
- self.assertEquals(b'\x00' * 16, f('0::0'))
- self.assertEquals(b'\x00\x01' + b'\x00' * 14, f('1::'))
- self.assertEquals(
+ self.assertEqual(b'\x00' * 16, f('::'))
+ self.assertEqual(b'\x00' * 16, f('0::0'))
+ self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::'))
+ self.assertEqual(
b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
)
@@ -470,14 +470,14 @@
from socket import inet_ntoa as f, inet_ntop, AF_INET
g = lambda a: inet_ntop(AF_INET, a)
- self.assertEquals('1.0.1.0', f(b'\x01\x00\x01\x00'))
- self.assertEquals('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
- self.assertEquals('255.255.255.255', f(b'\xff\xff\xff\xff'))
- self.assertEquals('1.2.3.4', f(b'\x01\x02\x03\x04'))
+ self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00'))
+ self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
+ self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff'))
+ self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04'))
- self.assertEquals('1.0.1.0', g(b'\x01\x00\x01\x00'))
- self.assertEquals('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
- self.assertEquals('255.255.255.255', g(b'\xff\xff\xff\xff'))
+ self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00'))
+ self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
+ self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff'))
def testStringToIPv6(self):
if not hasattr(socket, 'inet_ntop'):
@@ -490,9 +490,9 @@
return
f = lambda a: inet_ntop(AF_INET6, a)
- self.assertEquals('::', f(b'\x00' * 16))
- self.assertEquals('::1', f(b'\x00' * 15 + b'\x01'))
- self.assertEquals(
+ self.assertEqual('::', f(b'\x00' * 16))
+ self.assertEqual('::1', f(b'\x00' * 15 + b'\x01'))
+ self.assertEqual(
'aef:b01:506:1001:ffff:9997:55:170',
f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
)
@@ -1193,7 +1193,7 @@
self.cli = socket.create_connection((HOST, self.port))
finally:
socket.setdefaulttimeout(None)
- self.assertEquals(self.cli.gettimeout(), 42)
+ self.assertEqual(self.cli.gettimeout(), 42)
testTimeoutNone = _justAccept
def _testTimeoutNone(self):
diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py
index 6819f30..a098edd 100644
--- a/Lib/test/test_socketserver.py
+++ b/Lib/test/test_socketserver.py
@@ -57,8 +57,8 @@
os._exit(72)
yield None
pid2, status = os.waitpid(pid, 0)
- testcase.assertEquals(pid2, pid)
- testcase.assertEquals(72 << 8, status)
+ testcase.assertEqual(pid2, pid)
+ testcase.assertEqual(72 << 8, status)
@unittest.skipUnless(threading, 'Threading required for this test.')
@@ -120,7 +120,7 @@
if verbose: print("creating server")
server = MyServer(addr, MyHandler)
- self.assertEquals(server.server_address, server.socket.getsockname())
+ self.assertEqual(server.server_address, server.socket.getsockname())
return server
def run_server(self, svrcls, hdlrbase, testfunc):
@@ -159,7 +159,7 @@
while data and b'\n' not in buf:
data = receive(s, 100)
buf += data
- self.assertEquals(buf, TEST_STR)
+ self.assertEqual(buf, TEST_STR)
s.close()
def dgram_examine(self, proto, addr):
@@ -169,7 +169,7 @@
while data and b'\n' not in buf:
data = receive(s, 100)
buf += data
- self.assertEquals(buf, TEST_STR)
+ self.assertEqual(buf, TEST_STR)
s.close()
def test_TCPServer(self):
diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py
index 9d82f38..41bcac9 100644
--- a/Lib/test/test_structmembers.py
+++ b/Lib/test/test_structmembers.py
@@ -28,64 +28,64 @@
def test_bool(self):
ts.T_BOOL = True
- self.assertEquals(ts.T_BOOL, True)
+ self.assertEqual(ts.T_BOOL, True)
ts.T_BOOL = False
- self.assertEquals(ts.T_BOOL, False)
+ self.assertEqual(ts.T_BOOL, False)
self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1)
def test_byte(self):
ts.T_BYTE = CHAR_MAX
- self.assertEquals(ts.T_BYTE, CHAR_MAX)
+ self.assertEqual(ts.T_BYTE, CHAR_MAX)
ts.T_BYTE = CHAR_MIN
- self.assertEquals(ts.T_BYTE, CHAR_MIN)
+ self.assertEqual(ts.T_BYTE, CHAR_MIN)
ts.T_UBYTE = UCHAR_MAX
- self.assertEquals(ts.T_UBYTE, UCHAR_MAX)
+ self.assertEqual(ts.T_UBYTE, UCHAR_MAX)
def test_short(self):
ts.T_SHORT = SHRT_MAX
- self.assertEquals(ts.T_SHORT, SHRT_MAX)
+ self.assertEqual(ts.T_SHORT, SHRT_MAX)
ts.T_SHORT = SHRT_MIN
- self.assertEquals(ts.T_SHORT, SHRT_MIN)
+ self.assertEqual(ts.T_SHORT, SHRT_MIN)
ts.T_USHORT = USHRT_MAX
- self.assertEquals(ts.T_USHORT, USHRT_MAX)
+ self.assertEqual(ts.T_USHORT, USHRT_MAX)
def test_int(self):
ts.T_INT = INT_MAX
- self.assertEquals(ts.T_INT, INT_MAX)
+ self.assertEqual(ts.T_INT, INT_MAX)
ts.T_INT = INT_MIN
- self.assertEquals(ts.T_INT, INT_MIN)
+ self.assertEqual(ts.T_INT, INT_MIN)
ts.T_UINT = UINT_MAX
- self.assertEquals(ts.T_UINT, UINT_MAX)
+ self.assertEqual(ts.T_UINT, UINT_MAX)
def test_long(self):
ts.T_LONG = LONG_MAX
- self.assertEquals(ts.T_LONG, LONG_MAX)
+ self.assertEqual(ts.T_LONG, LONG_MAX)
ts.T_LONG = LONG_MIN
- self.assertEquals(ts.T_LONG, LONG_MIN)
+ self.assertEqual(ts.T_LONG, LONG_MIN)
ts.T_ULONG = ULONG_MAX
- self.assertEquals(ts.T_ULONG, ULONG_MAX)
+ self.assertEqual(ts.T_ULONG, ULONG_MAX)
def test_py_ssize_t(self):
ts.T_PYSSIZET = PY_SSIZE_T_MAX
- self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MAX)
+ self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MAX)
ts.T_PYSSIZET = PY_SSIZE_T_MIN
- self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MIN)
+ self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MIN)
@unittest.skipUnless(hasattr(ts, "T_LONGLONG"), "long long not present")
def test_longlong(self):
ts.T_LONGLONG = LLONG_MAX
- self.assertEquals(ts.T_LONGLONG, LLONG_MAX)
+ self.assertEqual(ts.T_LONGLONG, LLONG_MAX)
ts.T_LONGLONG = LLONG_MIN
- self.assertEquals(ts.T_LONGLONG, LLONG_MIN)
+ self.assertEqual(ts.T_LONGLONG, LLONG_MIN)
ts.T_ULONGLONG = ULLONG_MAX
- self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX)
+ self.assertEqual(ts.T_ULONGLONG, ULLONG_MAX)
## make sure these will accept a plain int as well as a long
ts.T_LONGLONG = 3
- self.assertEquals(ts.T_LONGLONG, 3)
+ self.assertEqual(ts.T_LONGLONG, 3)
ts.T_ULONGLONG = 4
- self.assertEquals(ts.T_ULONGLONG, 4)
+ self.assertEqual(ts.T_ULONGLONG, 4)
def test_bad_assignments(self):
integer_attributes = [
@@ -106,7 +106,7 @@
self.assertRaises(TypeError, setattr, ts, attr, nonint)
def test_inplace_string(self):
- self.assertEquals(ts.T_STRING_INPLACE, "hi")
+ self.assertEqual(ts.T_STRING_INPLACE, "hi")
self.assertRaises(TypeError, setattr, ts, "T_STRING_INPLACE", "s")
self.assertRaises(TypeError, delattr, ts, "T_STRING_INPLACE")
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index f2dbdc2..2379b3e 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -276,7 +276,7 @@
# stdout is set to 1 (#1531862).
cmd = r"import sys, os; sys.exit(os.write(sys.stdout.fileno(), b'.\n'))"
rc = subprocess.call([sys.executable, "-c", cmd], stdout=1)
- self.assertEquals(rc, 2)
+ self.assertEqual(rc, 2)
def test_cwd(self):
tmpdir = tempfile.gettempdir()
@@ -566,7 +566,7 @@
"[sys.executable, '-c', 'print(\"Hello World!\")'])",
'assert retcode == 0'))
output = subprocess.check_output([sys.executable, '-c', code])
- self.assert_(output.startswith(b'Hello World!'), ascii(output))
+ self.assertTrue(output.startswith(b'Hello World!'), ascii(output))
def test_handles_closed_on_exception(self):
# If CreateProcess exits with an error, ensure the
@@ -779,7 +779,7 @@
[sys.executable, "-c", script],
env=env)
stdout = stdout.rstrip(b'\n\r')
- self.assertEquals(stdout, value_repr)
+ self.assertEqual(stdout, value_repr)
# test bytes
key = key.encode("ascii", "surrogateescape")
@@ -791,7 +791,7 @@
[sys.executable, "-c", script],
env=env)
stdout = stdout.rstrip(b'\n\r')
- self.assertEquals(stdout, value_repr)
+ self.assertEqual(stdout, value_repr)
#
# Windows tests
@@ -897,9 +897,9 @@
if os.name == 'posix':
def test_getoutput(self):
- self.assertEquals(subprocess.getoutput('echo xyzzy'), 'xyzzy')
- self.assertEquals(subprocess.getstatusoutput('echo xyzzy'),
- (0, 'xyzzy'))
+ self.assertEqual(subprocess.getoutput('echo xyzzy'), 'xyzzy')
+ self.assertEqual(subprocess.getstatusoutput('echo xyzzy'),
+ (0, 'xyzzy'))
# we use mkdtemp in the next line to create an empty directory
# under our exclusive control; from that, we can invent a pathname
@@ -910,7 +910,7 @@
name = os.path.join(dir, "foo")
status, output = subprocess.getstatusoutput('cat ' + name)
- self.assertNotEquals(status, 0)
+ self.assertNotEqual(status, 0)
finally:
if dir is not None:
os.rmdir(dir)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index ccad44a..aa30923 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -86,7 +86,7 @@
try:
sys.exit(0)
except SystemExit as exc:
- self.assertEquals(exc.code, 0)
+ self.assertEqual(exc.code, 0)
except:
self.fail("wrong exception")
else:
@@ -97,7 +97,7 @@
try:
sys.exit(42)
except SystemExit as exc:
- self.assertEquals(exc.code, 42)
+ self.assertEqual(exc.code, 42)
except:
self.fail("wrong exception")
else:
@@ -107,7 +107,7 @@
try:
sys.exit((42,))
except SystemExit as exc:
- self.assertEquals(exc.code, 42)
+ self.assertEqual(exc.code, 42)
except:
self.fail("wrong exception")
else:
@@ -117,7 +117,7 @@
try:
sys.exit("exit")
except SystemExit as exc:
- self.assertEquals(exc.code, "exit")
+ self.assertEqual(exc.code, "exit")
except:
self.fail("wrong exception")
else:
@@ -127,7 +127,7 @@
try:
sys.exit((17, 23))
except SystemExit as exc:
- self.assertEquals(exc.code, (17, 23))
+ self.assertEqual(exc.code, (17, 23))
except:
self.fail("wrong exception")
else:
@@ -171,7 +171,7 @@
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
- self.assertEquals(sys.getcheckinterval(), n)
+ self.assertEqual(sys.getcheckinterval(), n)
def test_recursionlimit(self):
self.assertRaises(TypeError, sys.getrecursionlimit, 42)
@@ -438,8 +438,8 @@
p = subprocess.Popen([sys.executable, "-c", code], stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
self.assertEqual(p.returncode, 1)
- self.assert_(b"UnicodeEncodeError:" in stderr,
- "%r not in %s" % (b"UniodeEncodeError:", ascii(stderr)))
+ self.assertTrue(b"UnicodeEncodeError:" in stderr,
+ "%r not in %s" % (b"UnicodeEncodeError:", ascii(stderr)))
def test_sys_flags(self):
self.assertTrue(sys.flags)
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 403dd93..f48ab88 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -314,7 +314,7 @@
f.write(b"blat\x1a")
f.write(b"extra\n")
os.lseek(f.fd, 0, os.SEEK_SET)
- self.assertEquals(os.read(f.fd, 20), b"blat")
+ self.assertEqual(os.read(f.fd, 20), b"blat")
test_classes.append(test__mkstemp_inner)
@@ -872,7 +872,7 @@
with tempfile.TemporaryFile(*args, **kwargs) as fileobj:
fileobj.write(input)
fileobj.seek(0)
- self.assertEquals(input, fileobj.read())
+ self.assertEqual(input, fileobj.read())
roundtrip(b"1234", "w+b")
roundtrip("abdc\n", "w+")
diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py
index ffd59c3..905dd4c 100644
--- a/Lib/test/test_textwrap.py
+++ b/Lib/test/test_textwrap.py
@@ -29,7 +29,7 @@
def check(self, result, expect):
- self.assertEquals(result, expect,
+ self.assertEqual(result, expect,
'expected:\n%s\nbut got:\n%s' % (
self.show(expect), self.show(result)))
@@ -39,9 +39,9 @@
def check_split(self, text, expect):
result = self.wrapper._split(text)
- self.assertEquals(result, expect,
- "\nexpected %r\n"
- "but got %r" % (expect, result))
+ self.assertEqual(result, expect,
+ "\nexpected %r\n"
+ "but got %r" % (expect, result))
class WrapTestCase(BaseTestCase):
@@ -490,7 +490,7 @@
def assertUnchanged(self, text):
"""assert that dedent() has no effect on 'text'"""
- self.assertEquals(text, dedent(text))
+ self.assertEqual(text, dedent(text))
def test_dedent_nomargin(self):
# No lines indented.
@@ -513,17 +513,17 @@
# All lines indented by two spaces.
text = " Hello there.\n How are ya?\n Oh good."
expect = "Hello there.\nHow are ya?\nOh good."
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# Same, with blank lines.
text = " Hello there.\n\n How are ya?\n Oh good.\n"
expect = "Hello there.\n\nHow are ya?\nOh good.\n"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# Now indent one of the blank lines.
text = " Hello there.\n \n How are ya?\n Oh good.\n"
expect = "Hello there.\n\nHow are ya?\nOh good.\n"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
def test_dedent_uneven(self):
# Lines indented unevenly.
@@ -537,27 +537,27 @@
while 1:
return foo
'''
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# Uneven indentation with a blank line.
text = " Foo\n Bar\n\n Baz\n"
expect = "Foo\n Bar\n\n Baz\n"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# Uneven indentation with a whitespace-only line.
text = " Foo\n Bar\n \n Baz\n"
expect = "Foo\n Bar\n\n Baz\n"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# dedent() should not mangle internal tabs
def test_dedent_preserve_internal_tabs(self):
text = " hello\tthere\n how are\tyou?"
expect = "hello\tthere\nhow are\tyou?"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
# make sure that it preserves tabs when it's not making any
# changes at all
- self.assertEquals(expect, dedent(expect))
+ self.assertEqual(expect, dedent(expect))
# dedent() should not mangle tabs in the margin (i.e.
# tabs and spaces both count as margin, but are *not*
@@ -573,17 +573,17 @@
# dedent() only removes whitespace that can be uniformly removed!
text = "\thello there\n\thow are you?"
expect = "hello there\nhow are you?"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
text = " \thello there\n \thow are you?"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
text = " \t hello there\n \t how are you?"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
text = " \thello there\n \t how are you?"
expect = "hello there\n how are you?"
- self.assertEquals(expect, dedent(text))
+ self.assertEqual(expect, dedent(text))
def test_main():
diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py
index f6ce1ae..a86f86b 100644
--- a/Lib/test/test_thread.py
+++ b/Lib/test/test_thread.py
@@ -61,10 +61,10 @@
def test_stack_size(self):
# Various stack size tests.
- self.assertEquals(thread.stack_size(), 0, "intial stack size is not 0")
+ self.assertEqual(thread.stack_size(), 0, "intial stack size is not 0")
thread.stack_size(0)
- self.assertEquals(thread.stack_size(), 0, "stack_size not reset to default")
+ self.assertEqual(thread.stack_size(), 0, "stack_size not reset to default")
if os.name not in ("nt", "os2", "posix"):
return
@@ -84,7 +84,7 @@
fail_msg = "stack_size(%d) failed - should succeed"
for tss in (262144, 0x100000, 0):
thread.stack_size(tss)
- self.assertEquals(thread.stack_size(), tss, fail_msg % tss)
+ self.assertEqual(thread.stack_size(), tss, fail_msg % tss)
verbose_print("successfully set stack_size(%d)" % tss)
for tss in (262144, 0x100000):
diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py
index 6d84e7e..745c602 100644
--- a/Lib/test/test_threadedtempfile.py
+++ b/Lib/test/test_threadedtempfile.py
@@ -69,8 +69,8 @@
msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok,
'\n'.join(errors))
- self.assertEquals(errors, [], msg)
- self.assertEquals(ok, NUM_THREADS * FILES_PER_THREAD)
+ self.assertEqual(errors, [], msg)
+ self.assertEqual(ok, NUM_THREADS * FILES_PER_THREAD)
def test_main():
run_unittest(ThreadedTempFileTest)
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index f691336..587004a 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -371,17 +371,17 @@
weak_cyclic_object = weakref.ref(cyclic_object)
cyclic_object.thread.join()
del cyclic_object
- self.assertEquals(None, weak_cyclic_object(),
- msg=('%d references still around' %
- sys.getrefcount(weak_cyclic_object())))
+ self.assertEqual(None, weak_cyclic_object(),
+ msg=('%d references still around' %
+ sys.getrefcount(weak_cyclic_object())))
raising_cyclic_object = RunSelfFunction(should_raise=True)
weak_raising_cyclic_object = weakref.ref(raising_cyclic_object)
raising_cyclic_object.thread.join()
del raising_cyclic_object
- self.assertEquals(None, weak_raising_cyclic_object(),
- msg=('%d references still around' %
- sys.getrefcount(weak_raising_cyclic_object())))
+ self.assertEqual(None, weak_raising_cyclic_object(),
+ msg=('%d references still around' %
+ sys.getrefcount(weak_raising_cyclic_object())))
def test_old_threading_api(self):
# Just a quick sanity check to make sure the old method names are
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 49a9d17..4b5d703 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -99,7 +99,7 @@
# based on its value.
expected = "2000 01 01 00 00 00 1 001"
result = time.strftime("%Y %m %d %H %M %S %w %j", (0,)*9)
- self.assertEquals(expected, result)
+ self.assertEqual(expected, result)
def test_strptime(self):
# Should be able to go round-trip from strftime to strptime without
diff --git a/Lib/test/test_tokenize.py b/Lib/test/test_tokenize.py
index 482af94..510e632 100644
--- a/Lib/test/test_tokenize.py
+++ b/Lib/test/test_tokenize.py
@@ -690,8 +690,8 @@
# skip the initial encoding token and the end token
tokens = list(_tokenize(readline, encoding='utf-8'))[1:-1]
expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')]
- self.assertEquals(tokens, expected_tokens,
- "bytes not decoded with encoding")
+ self.assertEqual(tokens, expected_tokens,
+ "bytes not decoded with encoding")
def test__tokenize_does_not_decode_with_encoding_none(self):
literal = '"ЉЊЈЁЂ"'
@@ -707,8 +707,8 @@
# skip the end token
tokens = list(_tokenize(readline, encoding=None))[:-1]
expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')]
- self.assertEquals(tokens, expected_tokens,
- "string not tokenized when encoding is None")
+ self.assertEqual(tokens, expected_tokens,
+ "string not tokenized when encoding is None")
class TestDetectEncoding(TestCase):
@@ -731,8 +731,8 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, list(lines[:2]))
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, list(lines[:2]))
def test_bom_no_cookie(self):
lines = (
@@ -741,9 +741,9 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines,
- [b'# something\n', b'print(something)\n'])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines,
+ [b'# something\n', b'print(something)\n'])
def test_cookie_first_line_no_bom(self):
lines = (
@@ -752,8 +752,8 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'iso-8859-1')
- self.assertEquals(consumed_lines, [b'# -*- coding: latin-1 -*-\n'])
+ self.assertEqual(encoding, 'iso-8859-1')
+ self.assertEqual(consumed_lines, [b'# -*- coding: latin-1 -*-\n'])
def test_matched_bom_and_cookie_first_line(self):
lines = (
@@ -762,8 +762,8 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, [b'# coding=utf-8\n'])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, [b'# coding=utf-8\n'])
def test_mismatched_bom_and_cookie_first_line_raises_syntaxerror(self):
lines = (
@@ -782,9 +782,9 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'ascii')
+ self.assertEqual(encoding, 'ascii')
expected = [b'#! something\n', b'# vim: set fileencoding=ascii :\n']
- self.assertEquals(consumed_lines, expected)
+ self.assertEqual(consumed_lines, expected)
def test_matched_bom_and_cookie_second_line(self):
lines = (
@@ -794,9 +794,9 @@
b'do_something(else)\n'
)
encoding, consumed_lines = detect_encoding(self.get_readline(lines))
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines,
- [b'#! something\n', b'f# coding=utf-8\n'])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines,
+ [b'#! something\n', b'f# coding=utf-8\n'])
def test_mismatched_bom_and_cookie_second_line_raises_syntaxerror(self):
lines = (
@@ -821,7 +821,7 @@
b"do_something += 4\n")
rl = self.get_readline(lines)
found, consumed_lines = detect_encoding(rl)
- self.assertEquals(found, "iso-8859-1")
+ self.assertEqual(found, "iso-8859-1")
def test_utf8_normalization(self):
# See get_normal_name() in tokenizer.c.
@@ -834,27 +834,27 @@
b"1 + 3\n")
rl = self.get_readline(lines)
found, consumed_lines = detect_encoding(rl)
- self.assertEquals(found, "utf-8")
+ self.assertEqual(found, "utf-8")
def test_short_files(self):
readline = self.get_readline((b'print(something)\n',))
encoding, consumed_lines = detect_encoding(readline)
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, [b'print(something)\n'])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, [b'print(something)\n'])
encoding, consumed_lines = detect_encoding(self.get_readline(()))
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, [])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, [])
readline = self.get_readline((b'\xef\xbb\xbfprint(something)\n',))
encoding, consumed_lines = detect_encoding(readline)
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, [b'print(something)\n'])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, [b'print(something)\n'])
readline = self.get_readline((b'\xef\xbb\xbf',))
encoding, consumed_lines = detect_encoding(readline)
- self.assertEquals(encoding, 'utf-8')
- self.assertEquals(consumed_lines, [])
+ self.assertEqual(encoding, 'utf-8')
+ self.assertEqual(consumed_lines, [])
readline = self.get_readline((b'# coding: bad\n',))
self.assertRaises(SyntaxError, detect_encoding, readline)
@@ -893,7 +893,7 @@
tokenize_module._tokenize = mock__tokenize
try:
results = tokenize(mock_readline)
- self.assertEquals(list(results), ['first', 'second', 1, 2, 3, 4])
+ self.assertEqual(list(results), ['first', 'second', 1, 2, 3, 4])
finally:
tokenize_module.detect_encoding = orig_detect_encoding
tokenize_module._tokenize = orig__tokenize
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index 99d6a12..07c5062 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -289,7 +289,7 @@
self._coverage(tracer)
if os.path.exists(TESTFN):
files = os.listdir(TESTFN)
- self.assertEquals(files, [])
+ self.assertEqual(files, [])
def test_issue9936(self):
tracer = trace.Trace(trace=0, count=1)
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index b2c7262..f9e4458 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -171,11 +171,11 @@
raise Error("unable to create test traceback string")
# Make sure that Python and the traceback module format the same thing
- self.assertEquals(traceback_fmt, python_fmt)
+ self.assertEqual(traceback_fmt, python_fmt)
# Make sure that the traceback is properly indented.
tb_lines = python_fmt.splitlines()
- self.assertEquals(len(tb_lines), 3)
+ self.assertEqual(len(tb_lines), 3)
banner, location, source_line = tb_lines
self.assertTrue(banner.startswith('Traceback'))
self.assertTrue(location.startswith(' File'))
@@ -219,7 +219,7 @@
except ZeroDivisionError as _:
e = _
lines = self.get_report(e).splitlines()
- self.assertEquals(len(lines), 4)
+ self.assertEqual(len(lines), 4)
self.assertTrue(lines[0].startswith('Traceback'))
self.assertTrue(lines[1].startswith(' File'))
self.assertTrue('1/0 # Marker' in lines[2])
@@ -234,8 +234,8 @@
def outer_raise():
inner_raise() # Marker
blocks = boundaries.split(self.get_report(outer_raise))
- self.assertEquals(len(blocks), 3)
- self.assertEquals(blocks[1], cause_message)
+ self.assertEqual(len(blocks), 3)
+ self.assertEqual(blocks[1], cause_message)
self.check_zero_div(blocks[0])
self.assertTrue('inner_raise() # Marker' in blocks[2])
@@ -248,8 +248,8 @@
def outer_raise():
inner_raise() # Marker
blocks = boundaries.split(self.get_report(outer_raise))
- self.assertEquals(len(blocks), 3)
- self.assertEquals(blocks[1], context_message)
+ self.assertEqual(len(blocks), 3)
+ self.assertEqual(blocks[1], context_message)
self.check_zero_div(blocks[0])
self.assertTrue('inner_raise() # Marker' in blocks[2])
@@ -268,10 +268,10 @@
def outer_raise():
inner_raise() # Marker
blocks = boundaries.split(self.get_report(outer_raise))
- self.assertEquals(len(blocks), 3)
- self.assertEquals(blocks[1], cause_message)
+ self.assertEqual(len(blocks), 3)
+ self.assertEqual(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():
@@ -286,8 +286,8 @@
def outer_raise():
inner_raise() # Marker
blocks = boundaries.split(self.get_report(outer_raise))
- self.assertEquals(len(blocks), 3)
- self.assertEquals(blocks[1], cause_message)
+ self.assertEqual(len(blocks), 3)
+ self.assertEqual(blocks[1], cause_message)
# The first block is the KeyError raised from the ZeroDivisionError
self.assertTrue('raise KeyError from e' in blocks[0])
self.assertTrue('1/0' not in blocks[0])
@@ -320,7 +320,7 @@
traceback.format_exception(type(e), e, e.__traceback__))
with captured_output("stderr") as sio:
traceback.print_exception(type(e), e, e.__traceback__)
- self.assertEquals(sio.getvalue(), s)
+ self.assertEqual(sio.getvalue(), s)
return s
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 36a25c3..4793707 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -68,7 +68,7 @@
self.assertRaises(SyntaxError, eval, '\'\\Uffffffff\'')
self.assertRaises(SyntaxError, eval, '\'\\U%08x\'' % 0x110000)
# raw strings should not have unicode escapes
- self.assertNotEquals(r"\u0020", " ")
+ self.assertNotEqual(r"\u0020", " ")
def test_ascii(self):
if not sys.platform.startswith('java'):
@@ -1379,8 +1379,8 @@
def __str__(self):
return '__str__ overridden'
s = S('xxx')
- self.assertEquals("%s" % s, '__str__ overridden')
- self.assertEquals("{}".format(s), '__str__ overridden')
+ self.assertEqual("%s" % s, '__str__ overridden')
+ self.assertEqual("{}".format(s), '__str__ overridden')
def test_main():
diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py
index 43ac879..f8df2b6 100644
--- a/Lib/test/test_unicodedata.py
+++ b/Lib/test/test_unicodedata.py
@@ -253,7 +253,7 @@
self.assertTrue(count >= 10) # should have tested at least the ASCII digits
def test_bug_1704793(self):
- self.assertEquals(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346')
+ self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346')
def test_ucd_510(self):
import unicodedata
diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
index d59bf8a..ae91a87 100644
--- a/Lib/test/test_unittest.py
+++ b/Lib/test/test_unittest.py
@@ -2926,7 +2926,7 @@
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:
@@ -2943,7 +2943,7 @@
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:
@@ -2982,11 +2982,11 @@
self.assertFalse(TestCase.longMessage)
def test_formatMsg(self):
- self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo")
- self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo")
+ self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo")
+ self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo")
- self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
- self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
+ self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo")
+ self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
def assertMessages(self, methodName, args, errors):
def getMethod(i):
diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py
index 33c4e65..2b41ba1 100644
--- a/Lib/test/test_warnings.py
+++ b/Lib/test/test_warnings.py
@@ -81,7 +81,7 @@
self.module.resetwarnings()
self.module.filterwarnings("ignore", category=UserWarning)
self.module.warn("FilterTests.test_ignore", UserWarning)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
def test_always(self):
with original_warnings.catch_warnings(record=True,
@@ -103,10 +103,10 @@
for x in range(2):
self.module.warn(message, UserWarning)
if x == 0:
- self.assertEquals(w[-1].message, message)
+ self.assertEqual(w[-1].message, message)
del w[:]
elif x == 1:
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
else:
raise ValueError("loop variant unhandled")
@@ -117,10 +117,10 @@
self.module.filterwarnings("module", category=UserWarning)
message = UserWarning("FilterTests.test_module")
self.module.warn(message, UserWarning)
- self.assertEquals(w[-1].message, message)
+ self.assertEqual(w[-1].message, message)
del w[:]
self.module.warn(message, UserWarning)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
def test_once(self):
with original_warnings.catch_warnings(record=True,
@@ -130,14 +130,14 @@
message = UserWarning("FilterTests.test_once")
self.module.warn_explicit(message, UserWarning, "test_warnings.py",
42)
- self.assertEquals(w[-1].message, message)
+ self.assertEqual(w[-1].message, message)
del w[:]
self.module.warn_explicit(message, UserWarning, "test_warnings.py",
13)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
42)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
def test_inheritance(self):
with original_warnings.catch_warnings(module=self.module) as w:
@@ -158,7 +158,7 @@
self.module.warn("FilterTests.test_ordering", UserWarning)
except UserWarning:
self.fail("order handling for actions failed")
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
def test_filterwarnings(self):
# Test filterwarnings().
@@ -218,7 +218,7 @@
self.module.warn(ob)
# Don't directly compare objects since
# ``Warning() != Warning()``.
- self.assertEquals(str(w[-1].message), str(UserWarning(ob)))
+ self.assertEqual(str(w[-1].message), str(UserWarning(ob)))
def test_filename(self):
with warnings_state(self.module):
@@ -449,7 +449,7 @@
self.assertEqual(w[-1].message, message)
del w[:]
self.module.warn_explicit(message, UserWarning, "file", 42)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
# Test the resetting of onceregistry.
self.module.onceregistry = {}
__warningregistry__ = {}
@@ -460,7 +460,7 @@
del self.module.onceregistry
__warningregistry__ = {}
self.module.warn_explicit(message, UserWarning, "file", 42)
- self.assertEquals(len(w), 0)
+ self.assertEqual(len(w), 0)
finally:
self.module.onceregistry = original_registry
diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py
index 37ec2bc..f898bf7 100644
--- a/Lib/test/test_winreg.py
+++ b/Lib/test/test_winreg.py
@@ -64,12 +64,12 @@
# Check we wrote as many items as we thought.
nkeys, nvalues, since_mod = QueryInfoKey(key)
- self.assertEquals(nkeys, 1, "Not the correct number of sub keys")
- self.assertEquals(nvalues, 1, "Not the correct number of values")
+ self.assertEqual(nkeys, 1, "Not the correct number of sub keys")
+ self.assertEqual(nvalues, 1, "Not the correct number of values")
nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
- self.assertEquals(nkeys, 0, "Not the correct number of sub keys")
- self.assertEquals(nvalues, len(test_data),
- "Not the correct number of values")
+ self.assertEqual(nkeys, 0, "Not the correct number of sub keys")
+ self.assertEqual(nvalues, len(test_data),
+ "Not the correct number of values")
# Close this key this way...
# (but before we do, copy the key as an integer - this allows
# us to test that the key really gets closed).
@@ -94,8 +94,8 @@
def ReadTestData(self, root_key, subkeystr="sub_key"):
# Check we can get default value for this key.
val = QueryValue(root_key, test_key_name)
- self.assertEquals(val, "Default value",
- "Registry didn't give back the correct value")
+ self.assertEqual(val, "Default value",
+ "Registry didn't give back the correct value")
key = OpenKey(root_key, test_key_name)
# Read the sub-keys
@@ -107,22 +107,22 @@
data = EnumValue(sub_key, index)
except EnvironmentError:
break
- self.assertEquals(data in test_data, True,
- "Didn't read back the correct test data")
+ self.assertEqual(data in test_data, True,
+ "Didn't read back the correct test data")
index = index + 1
- self.assertEquals(index, len(test_data),
- "Didn't read the correct number of items")
+ self.assertEqual(index, len(test_data),
+ "Didn't read the correct number of items")
# Check I can directly access each item
for value_name, value_data, value_type in test_data:
read_val, read_typ = QueryValueEx(sub_key, value_name)
- self.assertEquals(read_val, value_data,
- "Could not directly read the value")
- self.assertEquals(read_typ, value_type,
- "Could not directly read the value")
+ self.assertEqual(read_val, value_data,
+ "Could not directly read the value")
+ self.assertEqual(read_typ, value_type,
+ "Could not directly read the value")
sub_key.Close()
# Enumerate our main key.
read_val = EnumKey(key, 0)
- self.assertEquals(read_val, subkeystr, "Read subkey value wrong")
+ self.assertEqual(read_val, subkeystr, "Read subkey value wrong")
try:
EnumKey(key, 1)
self.fail("Was able to get a second key when I only have one!")
@@ -141,8 +141,8 @@
DeleteValue(sub_key, value_name)
nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
- self.assertEquals(nkeys, 0, "subkey not empty before delete")
- self.assertEquals(nvalues, 0, "subkey not empty before delete")
+ self.assertEqual(nkeys, 0, "subkey not empty before delete")
+ self.assertEqual(nvalues, 0, "subkey not empty before delete")
sub_key.Close()
DeleteKey(key, subkeystr)
diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index ae2fa4d..66ff3b2 100644
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -726,10 +726,10 @@
def testEnterReturnsTuple(self):
with self.Dummy(value=(1,2)) as (a1, a2), \
self.Dummy(value=(10, 20)) as (b1, b2):
- self.assertEquals(1, a1)
- self.assertEquals(2, a2)
- self.assertEquals(10, b1)
- self.assertEquals(20, b2)
+ self.assertEqual(1, a1)
+ self.assertEqual(2, a2)
+ self.assertEqual(10, b1)
+ self.assertEqual(20, b2)
def test_main():
run_unittest(FailureTestCase, NonexceptionalTestCase,
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index c864940..9833f26 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -33,7 +33,7 @@
def test_dump_load(self):
dump = xmlrpclib.dumps((alist,))
load = xmlrpclib.loads(dump)
- self.assertEquals(alist, load[0][0])
+ self.assertEqual(alist, load[0][0])
def test_dump_bare_datetime(self):
# This checks that an unwrapped datetime.date object can be handled
@@ -43,22 +43,22 @@
dt = datetime.datetime(2005, 2, 10, 11, 41, 23)
s = xmlrpclib.dumps((dt,))
(newdt,), m = xmlrpclib.loads(s, use_datetime=1)
- self.assertEquals(newdt, dt)
- self.assertEquals(m, None)
+ self.assertEqual(newdt, dt)
+ self.assertEqual(m, None)
(newdt,), m = xmlrpclib.loads(s, use_datetime=0)
- self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
+ self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
def test_datetime_before_1900(self):
# same as before but with a date before 1900
dt = datetime.datetime(1, 2, 10, 11, 41, 23)
s = xmlrpclib.dumps((dt,))
(newdt,), m = xmlrpclib.loads(s, use_datetime=1)
- self.assertEquals(newdt, dt)
- self.assertEquals(m, None)
+ self.assertEqual(newdt, dt)
+ self.assertEqual(m, None)
(newdt,), m = xmlrpclib.loads(s, use_datetime=0)
- self.assertEquals(newdt, xmlrpclib.DateTime('00010210T11:41:23'))
+ self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23'))
def test_cmp_datetime_DateTime(self):
now = datetime.datetime.now()
@@ -86,7 +86,7 @@
t.x = 100
t.y = "Hello"
((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,)))
- self.assertEquals(t2, t.__dict__)
+ self.assertEqual(t2, t.__dict__)
def test_dump_big_long(self):
self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,))
@@ -132,14 +132,14 @@
value = alist + [None]
arg1 = (alist + [None],)
strg = xmlrpclib.dumps(arg1, allow_none=True)
- self.assertEquals(value,
+ self.assertEqual(value,
xmlrpclib.loads(strg)[0][0])
self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
def test_get_host_info(self):
# see bug #3613, this raised a TypeError
transp = xmlrpc.client.Transport()
- self.assertEquals(transp.get_host_info("user@host.tld"),
+ self.assertEqual(transp.get_host_info("user@host.tld"),
('host.tld',
[('Authorization', 'Basic dXNlcg==')], {}))
@@ -173,8 +173,8 @@
f = xmlrpclib.Fault(42, 'Test Fault')
s = xmlrpclib.dumps((f,))
(newf,), m = xmlrpclib.loads(s)
- self.assertEquals(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
- self.assertEquals(m, None)
+ self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
+ self.assertEqual(m, None)
s = xmlrpclib.Marshaller().dumps(f)
self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s)
@@ -648,7 +648,7 @@
content = handle[handle.find("<?xml"):]
- self.assertEquals(
+ self.assertEqual(
int(re.search('Content-Length: (\d+)', handle).group(1)),
len(content))
diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile.py
index 0e67dbd..e32d2d0 100644
--- a/Lib/test/test_zipfile.py
+++ b/Lib/test/test_zipfile.py
@@ -55,20 +55,20 @@
directory = fp.getvalue()
lines = directory.splitlines()
- self.assertEquals(len(lines), 4) # Number of files + header
+ self.assertEqual(len(lines), 4) # Number of files + header
self.assertTrue('File Name' in lines[0])
self.assertTrue('Modified' in lines[0])
self.assertTrue('Size' in lines[0])
fn, date, time, size = lines[1].split()
- self.assertEquals(fn, 'another.name')
+ self.assertEqual(fn, 'another.name')
# XXX: timestamp is not tested
- self.assertEquals(size, str(len(self.data)))
+ self.assertEqual(size, str(len(self.data)))
# Check the namelist
names = zipfp.namelist()
- self.assertEquals(len(names), 3)
+ self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names)
self.assertTrue("another.name" in names)
self.assertTrue("strfile" in names)
@@ -76,18 +76,18 @@
# Check infolist
infos = zipfp.infolist()
names = [ i.filename for i in infos ]
- self.assertEquals(len(names), 3)
+ self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names)
self.assertTrue("another.name" in names)
self.assertTrue("strfile" in names)
for i in infos:
- self.assertEquals(i.file_size, len(self.data))
+ self.assertEqual(i.file_size, len(self.data))
# check getinfo
for nm in (TESTFN, "another.name", "strfile"):
info = zipfp.getinfo(nm)
- self.assertEquals(info.filename, nm)
- self.assertEquals(info.file_size, len(self.data))
+ self.assertEqual(info.filename, nm)
+ self.assertEqual(info.file_size, len(self.data))
# Check that testzip doesn't raise an exception
zipfp.testzip()
@@ -445,20 +445,20 @@
directory = fp.getvalue()
lines = directory.splitlines()
- self.assertEquals(len(lines), 4) # Number of files + header
+ self.assertEqual(len(lines), 4) # Number of files + header
self.assertTrue('File Name' in lines[0])
self.assertTrue('Modified' in lines[0])
self.assertTrue('Size' in lines[0])
fn, date, time, size = lines[1].split()
- self.assertEquals(fn, 'another.name')
+ self.assertEqual(fn, 'another.name')
# XXX: timestamp is not tested
- self.assertEquals(size, str(len(self.data)))
+ self.assertEqual(size, str(len(self.data)))
# Check the namelist
names = zipfp.namelist()
- self.assertEquals(len(names), 3)
+ self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names)
self.assertTrue("another.name" in names)
self.assertTrue("strfile" in names)
@@ -466,18 +466,18 @@
# Check infolist
infos = zipfp.infolist()
names = [ i.filename for i in infos ]
- self.assertEquals(len(names), 3)
+ self.assertEqual(len(names), 3)
self.assertTrue(TESTFN in names)
self.assertTrue("another.name" in names)
self.assertTrue("strfile" in names)
for i in infos:
- self.assertEquals(i.file_size, len(self.data))
+ self.assertEqual(i.file_size, len(self.data))
# check getinfo
for nm in (TESTFN, "another.name", "strfile"):
info = zipfp.getinfo(nm)
- self.assertEquals(info.filename, nm)
- self.assertEquals(info.file_size, len(self.data))
+ self.assertEqual(info.filename, nm)
+ self.assertEqual(info.file_size, len(self.data))
# Check that testzip doesn't raise an exception
zipfp.testzip()
@@ -962,9 +962,9 @@
def testGoodPassword(self):
self.zip.setpassword(b"python")
- self.assertEquals(self.zip.read("test.txt"), self.plain)
+ self.assertEqual(self.zip.read("test.txt"), self.plain)
self.zip2.setpassword(b"12345")
- self.assertEquals(self.zip2.read("zero"), self.plain2)
+ self.assertEqual(self.zip2.read("zero"), self.plain2)
class TestsWithRandomBinaryFiles(unittest.TestCase):
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index 5d163c7..ebf6ad4 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -96,8 +96,8 @@
if expected_ext:
file = mod.get_file()
- self.assertEquals(file, os.path.join(TEMP_ZIP,
- *modules) + expected_ext)
+ self.assertEqual(file, os.path.join(TEMP_ZIP,
+ *modules) + expected_ext)
finally:
z.close()
os.remove(TEMP_ZIP)
@@ -209,31 +209,31 @@
z.close()
zi = zipimport.zipimporter(TEMP_ZIP)
- self.assertEquals(zi.archive, TEMP_ZIP)
- self.assertEquals(zi.is_package(TESTPACK), True)
+ self.assertEqual(zi.archive, TEMP_ZIP)
+ self.assertEqual(zi.is_package(TESTPACK), True)
mod = zi.load_module(TESTPACK)
- self.assertEquals(zi.get_filename(TESTPACK), mod.__file__)
+ self.assertEqual(zi.get_filename(TESTPACK), mod.__file__)
- self.assertEquals(zi.is_package(packdir + '__init__'), False)
- self.assertEquals(zi.is_package(packdir + TESTPACK2), True)
- self.assertEquals(zi.is_package(packdir2 + TESTMOD), False)
+ self.assertEqual(zi.is_package(packdir + '__init__'), False)
+ self.assertEqual(zi.is_package(packdir + TESTPACK2), True)
+ self.assertEqual(zi.is_package(packdir2 + TESTMOD), False)
mod_path = packdir2 + TESTMOD
mod_name = module_path_to_dotted_name(mod_path)
pkg = __import__(mod_name)
mod = sys.modules[mod_name]
- self.assertEquals(zi.get_source(TESTPACK), None)
- self.assertEquals(zi.get_source(mod_path), None)
- self.assertEquals(zi.get_filename(mod_path), mod.__file__)
+ self.assertEqual(zi.get_source(TESTPACK), None)
+ self.assertEqual(zi.get_source(mod_path), None)
+ self.assertEqual(zi.get_filename(mod_path), mod.__file__)
# To pass in the module name instead of the path, we must use the right importer
loader = mod.__loader__
- self.assertEquals(loader.get_source(mod_name), None)
- self.assertEquals(loader.get_filename(mod_name), mod.__file__)
+ self.assertEqual(loader.get_source(mod_name), None)
+ self.assertEqual(loader.get_filename(mod_name), mod.__file__)
# test prefix and archivepath members
zi2 = zipimport.zipimporter(TEMP_ZIP + os.sep + TESTPACK)
- self.assertEquals(zi2.archive, TEMP_ZIP)
- self.assertEquals(zi2.prefix, TESTPACK + os.sep)
+ self.assertEqual(zi2.archive, TEMP_ZIP)
+ self.assertEqual(zi2.prefix, TESTPACK + os.sep)
finally:
z.close()
os.remove(TEMP_ZIP)
@@ -253,26 +253,26 @@
z.close()
zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir)
- self.assertEquals(zi.archive, TEMP_ZIP)
- self.assertEquals(zi.prefix, packdir)
- self.assertEquals(zi.is_package(TESTPACK2), True)
+ self.assertEqual(zi.archive, TEMP_ZIP)
+ self.assertEqual(zi.prefix, packdir)
+ self.assertEqual(zi.is_package(TESTPACK2), True)
mod = zi.load_module(TESTPACK2)
- self.assertEquals(zi.get_filename(TESTPACK2), mod.__file__)
+ self.assertEqual(zi.get_filename(TESTPACK2), mod.__file__)
- self.assertEquals(zi.is_package(TESTPACK2 + os.sep + '__init__'), False)
- self.assertEquals(zi.is_package(TESTPACK2 + os.sep + TESTMOD), False)
+ self.assertEqual(zi.is_package(TESTPACK2 + os.sep + '__init__'), False)
+ self.assertEqual(zi.is_package(TESTPACK2 + os.sep + TESTMOD), False)
mod_path = TESTPACK2 + os.sep + TESTMOD
mod_name = module_path_to_dotted_name(mod_path)
pkg = __import__(mod_name)
mod = sys.modules[mod_name]
- self.assertEquals(zi.get_source(TESTPACK2), None)
- self.assertEquals(zi.get_source(mod_path), None)
- self.assertEquals(zi.get_filename(mod_path), mod.__file__)
+ self.assertEqual(zi.get_source(TESTPACK2), None)
+ self.assertEqual(zi.get_source(mod_path), None)
+ self.assertEqual(zi.get_filename(mod_path), mod.__file__)
# To pass in the module name instead of the path, we must use the right importer
loader = mod.__loader__
- self.assertEquals(loader.get_source(mod_name), None)
- self.assertEquals(loader.get_filename(mod_name), mod.__file__)
+ self.assertEqual(loader.get_source(mod_name), None)
+ self.assertEqual(loader.get_filename(mod_name), mod.__file__)
finally:
z.close()
os.remove(TEMP_ZIP)
@@ -286,7 +286,7 @@
z.writestr(name, data)
z.close()
zi = zipimport.zipimporter(TEMP_ZIP)
- self.assertEquals(data, zi.get_data(name))
+ self.assertEqual(data, zi.get_data(name))
self.assertTrue('zipimporter object' in repr(zi))
finally:
z.close()